@runopencode/rx-stencil 0.3.0

package/dist/collection/rx/observable/render-observable.js

@@ -0,0 +1,24 @@
+import { Observable, } from 'rxjs';
+/**
+ * Returns an observable that emits when the component render()
+ * function is called. Value will be emitted after the next
+ * microtask (next tick).
+ */
+export function renderObservable(cmp) {
+  if ('function' !== typeof cmp.render) {
+    throw new Error('Component does not have a render function.');
+  }
+  return new Observable((subscriber) => {
+    let previousRender = cmp.render;
+    cmp.render = function () {
+      Promise.resolve().then(() => {
+        subscriber.next();
+      });
+      return previousRender.call(this);
+    };
+    return () => {
+      cmp.render = previousRender;
+    };
+  });
+}
+//# sourceMappingURL=render-observable.js.map

package/dist/collection/rx/observable/render-observable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-observable.js","sourceRoot":"","sources":["../../../src/rx/observable/render-observable.ts"],"names":[],"mappings":"AACA,OAAO,EACH,UAAU,GAGb,MAAkC,MAAM,CAAC;AAE1C;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,GAAuB;EACpD,IAAI,UAAU,KAAK,OAAO,GAAG,CAAC,MAAM,EAAE;IAClC,MAAM,IAAI,KAAK,CAAC,4CAA4C,CAAC,CAAC;GACjE;EAED,OAAO,IAAI,UAAU,CAAO,CAAC,UAA4B,EAAiB,EAAE;IACxE,IAAI,cAAc,GAAc,GAAG,CAAC,MAAM,CAAC;IAE3C,GAAG,CAAC,MAAM,GAAG;MACT,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAS,EAAE;QAC9B,UAAU,CAAC,IAAI,EAAE,CAAC;MACtB,CAAC,CAAC,CAAC;MAEH,OAAO,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IACrC,CAAC,CAAA;IAED,OAAO,GAAS,EAAE;MACd,GAAG,CAAC,MAAM,GAAG,cAAc,CAAC;IAChC,CAAC,CAAA;EACL,CAAC,CAAC,CAAC;AACP,CAAC","sourcesContent":["import { ComponentInterface } from '@stencil/core';\nimport {\n    Observable,\n    Subscriber,\n    TeardownLogic,\n}                             from 'rxjs';\n\n/**\n * Returns an observable that emits when the component render()\n * function is called. Value will be emitted after the next\n * microtask (next tick).\n */\nexport function renderObservable(cmp: ComponentInterface): Observable<void> {\n    if ('function' !== typeof cmp.render) {\n        throw new Error('Component does not have a render function.');\n    }\n\n    return new Observable<void>((subscriber: Subscriber<void>): TeardownLogic => {\n        let previousRender: () => any = cmp.render;\n\n        cmp.render = function (): any {\n            Promise.resolve().then((): void => {\n                subscriber.next();\n            });\n\n            return previousRender.call(this);\n        }\n\n        return (): void => {\n            cmp.render = previousRender;\n        }\n    });\n}\n"]}

package/dist/collection/rx/operator/index.js

@@ -0,0 +1,4 @@
+export { scheduleRender } from './schedule-render';
+export { toProperty } from './to-property';
+export { untilDisconnected } from './until-disconnected';
+//# sourceMappingURL=index.js.map

package/dist/collection/rx/operator/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/rx/operator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAS,mBAAmB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAa,eAAe,CAAC;AAClD,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC","sourcesContent":["export { scheduleRender }    from './schedule-render';\nexport { toProperty }        from './to-property';\nexport { untilDisconnected } from './until-disconnected';\n"]}

package/dist/collection/rx/operator/schedule-render.js

@@ -0,0 +1,23 @@
+import { forceUpdate, } from '@stencil/core';
+import { tap, } from 'rxjs';
+/**
+ * Schedule a render of the component. This is useful when you
+ * want to force a render of the component as result of changing
+ * the values of the component which are not tracked by Stencil,
+ * observables, for example.
+ *
+ * By default, the render is scheduled on the next tick, but you
+ * can disable this behavior by passing `false` as second argument.
+ */
+export function scheduleRender(cmp, nextTick = true) {
+  return (source) => {
+    return source.pipe(tap(() => {
+      if (!nextTick) {
+        forceUpdate(cmp);
+        return;
+      }
+      Promise.resolve().then(() => forceUpdate(cmp));
+    }));
+  };
+}
+//# sourceMappingURL=schedule-render.js.map

package/dist/collection/rx/operator/schedule-render.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule-render.js","sourceRoot":"","sources":["../../../src/rx/operator/schedule-render.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,WAAW,GACd,MAAM,eAAe,CAAC;AACvB,OAAO,EAGH,GAAG,GACN,MAAM,MAAM,CAAC;AAEd;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc,CAAc,GAAuB,EAAE,WAAoB,IAAI;EACzF,OAAO,CAAC,MAAqB,EAAiB,EAAE;IAC5C,OAAO,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,GAAS,EAAE;MAC9B,IAAI,CAAC,QAAQ,EAAE;QACX,WAAW,CAAC,GAAG,CAAC,CAAC;QACjB,OAAO;OACV;MAED,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAS,EAAE,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC;IACzD,CAAC,CAAC,CAAC,CAAC;EACR,CAAC,CAAC;AACN,CAAC","sourcesContent":["import {\n    ComponentInterface,\n    forceUpdate,\n} from '@stencil/core';\nimport {\n    MonoTypeOperatorFunction,\n    Observable,\n    tap,\n} from 'rxjs';\n\n/**\n * Schedule a render of the component. This is useful when you\n * want to force a render of the component as result of changing\n * the values of the component which are not tracked by Stencil,\n * observables, for example.\n *\n * By default, the render is scheduled on the next tick, but you\n * can disable this behavior by passing `false` as second argument.\n */\nexport function scheduleRender<T = unknown>(cmp: ComponentInterface, nextTick: boolean = true): MonoTypeOperatorFunction<T> {\n    return (source: Observable<T>): Observable<T> => {\n        return source.pipe(tap((): void => {\n            if (!nextTick) {\n                forceUpdate(cmp);\n                return;\n            }\n\n            Promise.resolve().then((): void => forceUpdate(cmp));\n        }));\n    };\n}\n"]}

package/dist/collection/rx/operator/to-property.js

@@ -0,0 +1,19 @@
+import { tap, } from 'rxjs';
+import { getPropertyDescriptor } from '../../utils';
+/**
+ * Use this function to tap into a value stream and flush value to
+ * component property. You may also use this function as subscription
+ * function (function will detect that value is passed instead of
+ * observable).
+ */
+export function toProperty(cmp, property) {
+  // ensure that the property is defined on the component.
+  getPropertyDescriptor(cmp, property);
+  // @ts-ignore
+  return (source) => {
+    return source.pipe(tap((value) => {
+      cmp[property] = value;
+    }));
+  };
+}
+//# sourceMappingURL=to-property.js.map

package/dist/collection/rx/operator/to-property.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-property.js","sourceRoot":"","sources":["../../../src/rx/operator/to-property.ts"],"names":[],"mappings":"AACA,OAAO,EAEH,GAAG,GACN,MAAqC,MAAM,CAAC;AAC7C,OAAO,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AAEpD;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CAAU,GAAuB,EAAE,QAAgB;EACzE,wDAAwD;EACxD,qBAAqB,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;EAErC,aAAa;EACb,OAAO,CAAC,MAAqB,EAAwB,EAAE;IACnD,OAAO,MAAM,CAAC,IAAI,CACd,GAAG,CAAC,CAAC,KAAQ,EAAQ,EAAE;MACnB,GAAG,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC;IAC1B,CAAC,CAAC,CACL,CAAC;EACN,CAAC,CAAC;AACN,CAAC","sourcesContent":["import { ComponentInterface }             from '@stencil/core';\nimport {\n    MonoTypeOperatorFunction,\n    tap,\n}                                from 'rxjs';\nimport { getPropertyDescriptor } from '../../utils';\n\n/**\n * Use this function to tap into a value stream and flush value to\n * component property. You may also use this function as subscription\n * function (function will detect that value is passed instead of\n * observable).\n */\nexport function toProperty<T = any>(cmp: ComponentInterface, property: string): MonoTypeOperatorFunction<T> {\n    // ensure that the property is defined on the component.\n    getPropertyDescriptor(cmp, property);\n\n    // @ts-ignore\n    return (source: Observable<T>): Observable<T> | void => {\n        return source.pipe(\n            tap((value: T): void => {\n                cmp[property] = value;\n            }),\n        );\n    };\n}\n"]}

package/dist/collection/rx/operator/until-disconnected.js

@@ -0,0 +1,105 @@
+import { getElement, } from '@stencil/core';
+import { Observable, Subject, takeUntil, } from 'rxjs';
+/**
+ * A map of component observables that are being watched for
+ * disconnect callback invocation. A weak map is being used
+ * so that the component instance can be garbage collected.
+ *
+ * {@internal}
+ */
+let disconnectObservables = new WeakMap();
+/**
+ * Creates an observable that emits a value when the component
+ * is disconnected from DOM and method `disconnectedCallback()`
+ * is invoked. StencilJS will supress the invocation of this
+ * method if it is not defined on the component.
+ *
+ * {@internal}
+ */
+let createUsingDisconnectedCallback = function (cmp) {
+  let previousDisconnected = cmp.disconnectedCallback;
+  if (!previousDisconnected) {
+    throw new Error(`Component "${cmp.constructor.name}" does not have a "disconnectedCallback()" method defined.`);
+  }
+  let disconnectedSubject$ = new Subject();
+  cmp.disconnectedCallback = function () {
+    if (previousDisconnected) {
+      previousDisconnected.call(cmp);
+    }
+    disconnectedSubject$.next();
+  };
+  return disconnectedSubject$.asObservable();
+};
+/**
+ * Mutation observer is our next heuristic. We will monitor parent
+ * node of the component and emit a value when the component is
+ * disconnected from DOM. This will only work, of course, if the
+ * component is not the root node of the application and component
+ * is already within DOM.
+ *
+ * {@internal}
+ */
+let createUsingMutationObserver = function (cmp) {
+  let element = getElement(cmp);
+  if (null === element.parentNode) {
+    throw new Error(`Component "${cmp.constructor.name}" is not within DOM.`);
+  }
+  return new Observable((observer) => {
+    let mutationObserver = new MutationObserver((mutations) => {
+      mutations.forEach((record) => {
+        for (let node of Array.from(record.removedNodes)) {
+          if (node !== element) {
+            continue;
+          }
+          observer.next();
+          observer.complete();
+        }
+      });
+    });
+    mutationObserver.observe(element.parentNode, {
+      childList: true,
+      subtree: true,
+    });
+    return () => {
+      mutationObserver.disconnect();
+      // we can not re-use this observable, so we have to delete it
+      disconnectObservables.delete(cmp);
+    };
+  });
+};
+/**
+ * Creates an observable that emits a value when the component
+ * is disconnected from DOM.
+ *
+ * {@internal}
+ */
+function createDisconnectObservable(cmp) {
+  let functions = [
+    createUsingDisconnectedCallback,
+    createUsingMutationObserver,
+  ];
+  for (let fn of functions) {
+    try {
+      disconnectObservables.set(cmp, fn(cmp));
+      return;
+    }
+    catch (e) {
+      // noop
+    }
+  }
+  throw new Error(`Could not create disconnect observable for component "${cmp.constructor.name}".`);
+}
+/**
+ * Operator that unsubscribes from the source observable when
+ * the component is disconnected from DOM.
+ */
+export function untilDisconnected(cmp) {
+  return (source) => {
+    if (!disconnectObservables.has(cmp)) {
+      createDisconnectObservable(cmp);
+    }
+    let disconnectObservable$ = disconnectObservables.get(cmp);
+    return source.pipe(takeUntil(disconnectObservable$));
+  };
+}
+//# sourceMappingURL=until-disconnected.js.map

package/dist/collection/rx/operator/until-disconnected.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"until-disconnected.js","sourceRoot":"","sources":["../../../src/rx/operator/until-disconnected.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    ComponentInterface,\n    getElement,\n} from '@stencil/core';\nimport {\n    MonoTypeOperatorFunction,\n    Observable,\n    Subject,\n    Subscriber,\n    takeUntil,\n    TeardownLogic,\n} from 'rxjs';\n\n/**\n * A map of component observables that are being watched for\n * disconnect callback invocation. A weak map is being used\n * so that the component instance can be garbage collected.\n *\n * {@internal}\n */\nlet disconnectObservables: WeakMap<ComponentInterface, Observable<void>> = new WeakMap();\n\n/**\n * A function that creates an observable which emits an event\n * when the component is disconnected from DOM.\n *\n * {@internal}\n */\ntype CreateDisconnectObservableFn = (cmp: ComponentInterface) => Observable<void>;\n\n/**\n * Creates an observable that emits a value when the component\n * is disconnected from DOM and method `disconnectedCallback()`\n * is invoked. StencilJS will supress the invocation of this\n * method if it is not defined on the component.\n *\n * {@internal}\n */\nlet createUsingDisconnectedCallback: CreateDisconnectObservableFn = function (cmp: ComponentInterface): Observable<void> {\n    let previousDisconnected: Function | undefined = cmp.disconnectedCallback;\n\n    if (!previousDisconnected) {\n        throw new Error(`Component \"${cmp.constructor.name}\" does not have a \"disconnectedCallback()\" method defined.`);\n    }\n\n    let disconnectedSubject$: Subject<void> = new Subject<void>();\n\n    cmp.disconnectedCallback = function (): void {\n        if (previousDisconnected) {\n            previousDisconnected.call(cmp);\n        }\n\n        disconnectedSubject$.next();\n    };\n\n    return disconnectedSubject$.asObservable();\n}\n\n/**\n * Mutation observer is our next heuristic. We will monitor parent\n * node of the component and emit a value when the component is\n * disconnected from DOM. This will only work, of course, if the\n * component is not the root node of the application and component\n * is already within DOM.\n *\n * {@internal}\n */\nlet createUsingMutationObserver: CreateDisconnectObservableFn = function (cmp: ComponentInterface): Observable<void> {\n    let element: HTMLElement = getElement(cmp);\n\n    if (null === element.parentNode) {\n        throw new Error(`Component \"${cmp.constructor.name}\" is not within DOM.`);\n    }\n\n    return new Observable<void>((observer: Subscriber<void>): TeardownLogic => {\n\n        let mutationObserver: MutationObserver = new MutationObserver((mutations: MutationRecord[]): void => {\n            mutations.forEach((record: MutationRecord): void => {\n                for (let node of Array.from(record.removedNodes)) {\n                    if (node !== element) {\n                        continue;\n                    }\n\n                    observer.next();\n                    observer.complete();\n                }\n            });\n        });\n\n        mutationObserver.observe(element.parentNode, {\n            childList: true,\n            subtree:   true,\n        });\n\n        return (): void => {\n            mutationObserver.disconnect();\n            // we can not re-use this observable, so we have to delete it\n            disconnectObservables.delete(cmp);\n        };\n    });\n\n\n}\n\n/**\n * Creates an observable that emits a value when the component\n * is disconnected from DOM.\n *\n * {@internal}\n */\nfunction createDisconnectObservable(cmp: ComponentInterface): void {\n    let functions: CreateDisconnectObservableFn[] = [\n        createUsingDisconnectedCallback,\n        createUsingMutationObserver,\n    ];\n\n    for (let fn of functions) {\n        try {\n            disconnectObservables.set(cmp, fn(cmp));\n            return;\n        } catch (e) {\n            // noop\n        }\n    }\n\n    throw new Error(`Could not create disconnect observable for component \"${cmp.constructor.name}\".`);\n}\n\n/**\n * Operator that unsubscribes from the source observable when\n * the component is disconnected from DOM.\n */\nexport function untilDisconnected<T = unknown>(cmp: ComponentInterface): MonoTypeOperatorFunction<T> {\n    return (source: Observable<T>): Observable<T> => {\n        if (!disconnectObservables.has(cmp)) {\n            createDisconnectObservable(cmp);\n        }\n\n        let disconnectObservable$: Observable<void> = disconnectObservables.get(cmp);\n\n        return source.pipe(\n            takeUntil<T>(disconnectObservable$),\n        );\n    };\n}\n"]}

package/dist/collection/rx/subscriber/index.js

@@ -0,0 +1,2 @@
+export { setProperty, } from './set-property';
+//# sourceMappingURL=index.js.map

package/dist/collection/rx/subscriber/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/rx/subscriber/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,WAAW,GACd,MAAM,gBAAgB,CAAC","sourcesContent":["export {\n    SetPropertyOptions,\n    setProperty,\n} from './set-property';\n"]}

package/dist/collection/rx/subscriber/set-property.js

@@ -0,0 +1,16 @@
+import { forceUpdate, } from '@stencil/core';
+export function setProperty(cmp, property, options = {}) {
+  let resolvedOptions = Object.assign({ scheduleRender: false, nextTick: true }, options);
+  return (value) => {
+    cmp[property] = value;
+    if (!resolvedOptions.scheduleRender) {
+      return;
+    }
+    if (!resolvedOptions.nextTick) {
+      forceUpdate(cmp);
+      return;
+    }
+    Promise.resolve().then(() => forceUpdate(cmp));
+  };
+}
+//# sourceMappingURL=set-property.js.map

package/dist/collection/rx/subscriber/set-property.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-property.js","sourceRoot":"","sources":["../../../src/rx/subscriber/set-property.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,WAAW,GACd,MAAM,eAAe,CAAC;AAiBvB,MAAM,UAAU,WAAW,CAAU,GAAuB,EAAE,QAAgB,EAAE,UAA8B,EAAE;EAC5G,IAAI,eAAe,mBACf,cAAc,EAAE,KAAK,EACrB,QAAQ,EAAQ,IAAI,IACjB,OAAO,CACb,CAAC;EAEF,OAAO,CAAC,KAAQ,EAAQ,EAAE;IACtB,GAAG,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC;IAEtB,IAAI,CAAC,eAAe,CAAC,cAAc,EAAE;MACjC,OAAO;KACV;IAED,IAAI,CAAC,eAAe,CAAC,QAAQ,EAAE;MAC3B,WAAW,CAAC,GAAG,CAAC,CAAC;MACjB,OAAO;KACV;IAED,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,CAAC,GAAS,EAAE,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC;EACzD,CAAC,CAAC;AACN,CAAC","sourcesContent":["import {\n    ComponentInterface,\n    forceUpdate,\n} from '@stencil/core';\n\nexport type SetPropertyOptions = {\n    /**\n     * Whether to schedule a render of the component after the\n     * property is updated. By default, this value is set to\n     * `false`, assuming that the property is annotated with\n     * either @State or @Prop decorator.\n     */\n    scheduleRender?: boolean;\n    /**\n     * Whether to schedule a render of the component on the next\n     * tick. By default, this value is set to `true`.\n     */\n    nextTick?: boolean;\n}\n\nexport function setProperty<T = any>(cmp: ComponentInterface, property: string, options: SetPropertyOptions = {}): (value: T) => void {\n    let resolvedOptions: SetPropertyOptions = {\n        scheduleRender: false,\n        nextTick:       true,\n        ...options,\n    };\n\n    return (value: T): void => {\n        cmp[property] = value;\n\n        if (!resolvedOptions.scheduleRender) {\n            return;\n        }\n\n        if (!resolvedOptions.nextTick) {\n            forceUpdate(cmp);\n            return;\n        }\n\n        Promise.resolve().then((): void => forceUpdate(cmp));\n    };\n}\n"]}

package/dist/collection/utils/get-property-descriptor.js

@@ -0,0 +1,18 @@
+/**
+ * Returns property descriptor for the given property of the component.
+ *
+ * {@internal}
+ */
+export function getPropertyDescriptor(cmp, property, configurableRequired = true) {
+  // descriptors are defined on prototype, so we have to go one level up.
+  let prototype = Object.getPrototypeOf(cmp);
+  let descriptor = Object.getOwnPropertyDescriptor(prototype, property);
+  if (!descriptor) {
+    throw new Error(`Property "${property}" is not defined on component "${cmp.constructor.name}".`);
+  }
+  if (configurableRequired && !descriptor.configurable) {
+    throw new Error(`Property "${property}" is not configurable on component "${cmp.constructor.name}".`);
+  }
+  return descriptor;
+}
+//# sourceMappingURL=get-property-descriptor.js.map

package/dist/collection/utils/get-property-descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-property-descriptor.js","sourceRoot":"","sources":["../../src/utils/get-property-descriptor.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,GAAuB,EAAE,QAAgB,EAAE,uBAAgC,IAAI;EACjH,uEAAuE;EACvE,IAAI,SAAS,GAAwB,MAAM,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC;EAChE,IAAI,UAAU,GAAuB,MAAM,CAAC,wBAAwB,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;EAE1F,IAAI,CAAC,UAAU,EAAE;IACb,MAAM,IAAI,KAAK,CAAC,aAAa,QAAQ,kCAAkC,GAAG,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC,CAAC;GACpG;EAED,IAAI,oBAAoB,IAAI,CAAC,UAAU,CAAC,YAAY,EAAE;IAClD,MAAM,IAAI,KAAK,CAAC,aAAa,QAAQ,uCAAuC,GAAG,CAAC,WAAW,CAAC,IAAI,IAAI,CAAC,CAAC;GACzG;EAED,OAAO,UAAU,CAAC;AACtB,CAAC","sourcesContent":["import { ComponentInterface } from '@stencil/core';\n\n/**\n * Returns property descriptor for the given property of the component.\n *\n * {@internal}\n */\nexport function getPropertyDescriptor(cmp: ComponentInterface, property: string, configurableRequired: boolean = true): PropertyDescriptor {\n    // descriptors are defined on prototype, so we have to go one level up.\n    let prototype: object              = Object.getPrototypeOf(cmp);\n    let descriptor: PropertyDescriptor = Object.getOwnPropertyDescriptor(prototype, property);\n\n    if (!descriptor) {\n        throw new Error(`Property \"${property}\" is not defined on component \"${cmp.constructor.name}\".`);\n    }\n\n    if (configurableRequired && !descriptor.configurable) {\n        throw new Error(`Property \"${property}\" is not configurable on component \"${cmp.constructor.name}\".`);\n    }\n\n    return descriptor;\n}\n"]}

package/dist/collection/utils/index.js

@@ -0,0 +1,2 @@
+export { getPropertyDescriptor } from './get-property-descriptor';
+//# sourceMappingURL=index.js.map

package/dist/collection/utils/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC","sourcesContent":["export { getPropertyDescriptor } from './get-property-descriptor';\n"]}

package/dist/components/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Used to manually set the base path where assets can be found.
+ * If the script is used as "module", it's recommended to use "import.meta.url",
+ * such as "setAssetPath(import.meta.url)". Other options include
+ * "setAssetPath(document.currentScript.src)", or using a bundler's replace plugin to
+ * dynamically set the path at build time, such as "setAssetPath(process.env.ASSET_PATH)".
+ * But do note that this configuration depends on how your script is bundled, or lack of
+ * bundling, and where your assets can be loaded from. Additionally custom bundling
+ * will have to ensure the static assets are copied to its build directory.
+ */
+export declare const setAssetPath: (path: string) => void;
+
+/**
+ * Used to specify a nonce value that corresponds with an application's CSP.
+ * When set, the nonce will be added to all dynamically created script and style tags at runtime.
+ * Alternatively, the nonce value can be set on a meta tag in the DOM head
+ * (<meta name="csp-nonce" content="{ nonce value here }" />) which
+ * will result in the same behavior.
+ */
+export declare const setNonce: (nonce: string) => void
+
+export interface SetPlatformOptions {
+  raf?: (c: FrameRequestCallback) => number;
+  ael?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+  rel?: (el: EventTarget, eventName: string, listener: EventListenerOrEventListenerObject, options: boolean | AddEventListenerOptions) => void;
+}
+export declare const setPlatformOptions: (opts: SetPlatformOptions) => void;