hotfix(scripts): output script + minified script

Author: ljbc1994

src/Blazor.IntersectionObserver/Blazor.IntersectionObserver.csproj

@@ -58,7 +58,7 @@
 
   <ItemGroup>
     <!-- .js/.css files will be referenced via <script>/<link> tags; other content files will just be included in the app's 'dist' directory without any tags referencing them -->
-    <EmbeddedResource Include="wwwroot\**\*.min.js" LogicalName="blazor:js:%(RecursiveDir)%(Filename)%(Extension)" />
+    <EmbeddedResource Include="wwwroot\**\*.js" LogicalName="blazor:js:%(RecursiveDir)%(Filename)%(Extension)" />
     <EmbeddedResource Include="wwwroot\**\*.css" LogicalName="blazor:css:%(RecursiveDir)%(Filename)%(Extension)" />
     <EmbeddedResource Include="wwwroot\**" Exclude="**\*.js;**\*.css" LogicalName="blazor:file:%(RecursiveDir)%(Filename)%(Extension)" />
   </ItemGroup>
@@ -78,6 +78,9 @@
     <EmbeddedResource Update="wwwroot\blazor-intersection-observer.min.js">
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </EmbeddedResource>
+    <EmbeddedResource Update="wwwroot\blazor-intersection-observer.js">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </EmbeddedResource>
   </ItemGroup>
 
   <ItemGroup>

src/Blazor.IntersectionObserver/rollup.config.js

@@ -1,14 +1,27 @@
 import typescript from '@rollup/plugin-typescript';
 import { terser } from "rollup-plugin-terser";
 
-export default {
-  input: 'src/index.ts',
-  output: {
-    file: 'wwwroot/blazor-intersection-observer.min.js',
-    format: 'es',
-    sourcemap: false,
+export default [
+  {
+    input: 'src/index.ts',
+    output: {
+      file: 'wwwroot/blazor-intersection-observer.min.js',
+      format: 'es',
+      sourcemap: false,
+    },
+    plugins: [typescript({
+      sourceMap: false,
+    }), terser()],
   },
-  plugins: [typescript({
-    sourceMap: false,
-  }), terser()],
-};
+  {
+    input: 'src/index.ts',
+    output: {
+      file: 'wwwroot/blazor-intersection-observer.js',
+      format: 'es',
+      sourcemap: false,
+    },
+    plugins: [typescript({
+      sourceMap: false,
+    })],
+  }
+];

src/Blazor.IntersectionObserver/wwwroot/blazor-intersection-observer.js

@@ -0,0 +1,105 @@
+const OBSERVER_ID_PREFIX = "blazor_plugin_observer__";
+let OBSERVER_ID = 1;
+const observerItems = new Map();
+function reset() {
+    OBSERVER_ID = 0;
+    observerItems.clear();
+}
+function getObserverItems() {
+    return observerItems;
+}
+function getObserverElementId() {
+    return `${OBSERVER_ID_PREFIX}${OBSERVER_ID++}`;
+}
+function createObserverItem(dotnetRef, callbackId, options) {
+    const onEntry = onEntryChange(callbackId);
+    const observer = new IntersectionObserver(onEntry, options);
+    observerItems.set(callbackId, { dotnetRef, observer, elements: [] });
+    return observerItems.get(callbackId);
+}
+function observeElement(callbackId, element) {
+    const item = observerItems.get(callbackId);
+    if (item == null) {
+        throw new Error(`Failed to observe element for key: ${callbackId} as the observer does not exist`);
+    }
+    if (item.elements.some(record => record.element == element)) {
+        console.warn(`BlazorIntersectionObserver: The element is already being observed by observer for key ${callbackId}`);
+        return "";
+    }
+    const elementId = getObserverElementId();
+    item.observer.observe(element);
+    item.elements.push({ elementId, element });
+    return elementId;
+}
+function create(dotnetRef, callbackId, options) {
+    return createObserverItem(dotnetRef, callbackId, options);
+}
+function observe(dotnetRef, callbackId, node, options) {
+    createObserverItem(dotnetRef, callbackId, options);
+    return observeElement(callbackId, node);
+}
+function unobserve(callbackId, element) {
+    var _a;
+    const item = observerItems.get(callbackId);
+    if (item == null) {
+        throw new Error(`Failed to unobserve element for key: ${callbackId} as the observer does not exist`);
+    }
+    const unobserveElementId = (_a = item.elements.find((record) => record.element == element)) === null || _a === void 0 ? void 0 : _a.elementId;
+    if (unobserveElementId == null) {
+        console.warn(`BlazorIntersectionObserver: The record does not exist for observer: ${callbackId}`);
+    }
+    item.observer.unobserve(element);
+    item.elements = item.elements.filter((record) => record.element != element);
+    return unobserveElementId;
+}
+function disconnect(callbackId) {
+    const item = observerItems.get(callbackId);
+    if (item == null) {
+        throw new Error(`Failed to disconnect for key: ${callbackId} as the observer does not exist`);
+    }
+    item.observer.disconnect();
+    item.elements = [];
+    return true;
+}
+function remove(callbackId) {
+    if (disconnect(callbackId)) {
+        return observerItems.delete(callbackId);
+    }
+}
+function toEntryObject(entry) {
+    function toRectReadOnlyObject(obj) {
+        return {
+            X: obj.x,
+            Y: obj.y,
+            Width: obj.width,
+            Height: obj.height,
+            Top: obj.top,
+            Left: obj.left,
+            Bottom: obj.bottom,
+            Right: obj.right,
+        };
+    }
+    return {
+        IsIntersecting: entry.isIntersecting,
+        IntersectionRatio: entry.intersectionRatio,
+        Time: entry.time,
+        BoundingClientRect: toRectReadOnlyObject(entry.boundingClientRect),
+        IntersectionRect: toRectReadOnlyObject(entry.intersectionRect),
+        RootBounds: toRectReadOnlyObject(entry.rootBounds),
+    };
+}
+function onEntryChange(callbackId) {
+    return (entries) => {
+        if (!observerItems.has(callbackId)) {
+            return;
+        }
+        const { dotnetRef } = observerItems.get(callbackId);
+        const mapped = entries.map((entry) => {
+            const mappedEntry = toEntryObject(entry);
+            return mappedEntry;
+        });
+        dotnetRef.invokeMethodAsync("OnCallback", callbackId, mapped);
+    };
+}
+
+export { OBSERVER_ID_PREFIX, create, disconnect, getObserverItems, observe, observeElement, remove, reset, unobserve };