@jscutlery/microwave 0.1.0

package/README.md

@@ -0,0 +1,112 @@
+# Microwave
+
+`@jscutlery/microwave` brings simplified and performant reactivity to Angular.
+
+# 🪄 Features
+
+⚡️ Less change detection: Microwave will only trigger change detection when properties change.
+
+😌 Less RxJS Spaghetti: Focus on your features without sacrificing performance.
+
+🚦 Coalescing: regroup changes and trigger change detection once per component.
+
+✅ Microwave is ZoneJS agnostic so it will work with or without it.
+
+👯‍♀️ Don't trigger useless change detections when a property's value has been set to the same value.
+
+# Table of Contents
+
+- [Microwave](#microwave)
+- [🪄 Features](#-features)
+- [Table of Contents](#table-of-contents)
+- [📝 Usage](#-usage)
+  - [`@Microwave`](#microwave-1)
+  - [`@Microwave` + `watch`](#microwave--watch)
+  - [Change detection strategies](#change-detection-strategies)
+    - [Custom strategies.](#custom-strategies)
+  - [Upcoming features](#upcoming-features)
+- [Acknowledgements](#acknowledgements)
+  - [Nuke it](#nuke-it)
+
+# 📝 Usage
+
+## `@Microwave`
+
+Just add the `@Microwave` decorator and let it [nuke](#nuke-it) your component!
+
+```ts
+import { Microwave } from '@jscutlery/microwave';
+
+@Microwave()
+@Component({
+  template: `...`,
+})
+class GreetingsComponent {
+  /* ⚠️ Important: properties should be initialized, otherwise they won't be detected by Microwave. */
+  name?: string = undefined;
+}
+```
+
+## `@Microwave` + `watch`
+
+Watch property changes.
+
+```ts
+@Microwave()
+@Component({
+  template: `<h1>Welcome {{ upperCaseName }}</h1>`,
+})
+class GreetingsComponent {
+  @Input() name?: string = undefined;
+  upperCaseName?: string = undefined;
+
+  constructor() {
+    /* Note that you don't have to handle the subscription as the returned observable
+     * will be unsubscribed from when the component is destroyed.
+     * Though, if you add operators, you will have to handle subscriptions. */
+    watch(this, 'name').subscribe((name) => {
+      this.upperCaseName = name.toUpperCase();
+    });
+  }
+}
+```
+
+## Change detection strategies
+
+You can customize the change detection strategy using the `strategy` parameter.
+
+```ts
+@Microwave({
+  strategy: asyncStrategy,
+})
+export class MyComponent {}
+```
+
+Here are the current strategies.
+
+### Custom strategies.
+
+You can implement your own strategy using the `Strategy<T>` signature.
+
+| Strategy      | Description                                                                                                                                                                          |
+| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| asapStrategy  | This is the default strategy. It will trigger change detection independently for each component while coalescing changes and scheduling the change detection on the microtask queue. |
+| asyncStrategy | Local strategy coalescing using macrotasks                                                                                                                                           |
+| rafStrategy   | Local strategy coalescing using `requestAnimationFrame`                                                                                                                              |
+| syncStrategy  | Local strategy without coalescing so it will trigger change detection each time a property changes.                                                                                  |
+
+## Upcoming features
+
+- [ ] provide multiple Microwave strategies
+- [ ] `watch` multiple properties
+- [ ] automatically unsubscribe even when using operators with `watch(...).pipe(...)`
+
+# Acknowledgements
+
+The [RxAngular](https://github.com/rx-angular/rx-angular) team for the inspiration. In fact, the first prototype was built during the creation of the RxState Marmicode Tasting video: https://youtu.be/CcQYj4V2IKw
+
+## Nuke it
+
+Wordplay by [@AlyssaNicoll](https://twitter.com/AlyssaNicoll) & [@schwarty](https://twitter.com/schwarty).
+
+Cf. Angular Air [https://youtu.be/CmspcYY6jjU](https://youtu.be/CmspcYY6jjU)

package/esm2020/index.mjs

@@ -0,0 +1,3 @@
+export { Microwave, watch } from './lib/microwave';
+export { asapStrategy, asyncStrategy, createLocalStrategy, rafStrategy, syncStrategy, } from './lib/strategies';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wYWNrYWdlcy9taWNyb3dhdmUvc3JjL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUNBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDbkQsT0FBTyxFQUNMLFlBQVksRUFDWixhQUFhLEVBQ2IsbUJBQW1CLEVBQ25CLFdBQVcsRUFDWCxZQUFZLEdBQ2IsTUFBTSxrQkFBa0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IFN0cmF0ZWd5LCBTdHJhdGVneURldktpdCB9IGZyb20gJy4vbGliL2RldmtpdCc7XG5leHBvcnQgeyBNaWNyb3dhdmUsIHdhdGNoIH0gZnJvbSAnLi9saWIvbWljcm93YXZlJztcbmV4cG9ydCB7XG4gIGFzYXBTdHJhdGVneSxcbiAgYXN5bmNTdHJhdGVneSxcbiAgY3JlYXRlTG9jYWxTdHJhdGVneSxcbiAgcmFmU3RyYXRlZ3ksXG4gIHN5bmNTdHJhdGVneSxcbn0gZnJvbSAnLi9saWIvc3RyYXRlZ2llcyc7XG4iXX0=

package/esm2020/jscutlery-microwave.mjs

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './index';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoianNjdXRsZXJ5LW1pY3Jvd2F2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3BhY2thZ2VzL21pY3Jvd2F2ZS9zcmMvanNjdXRsZXJ5LW1pY3Jvd2F2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUVILGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBHZW5lcmF0ZWQgYnVuZGxlIGluZGV4LiBEbyBub3QgZWRpdC5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL2luZGV4JztcbiJdfQ==

package/esm2020/lib/apply-strategy.mjs

@@ -0,0 +1,34 @@
+import { getEngine } from './core/engine';
+import { getStrategyDevKit } from './devkit';
+import { decorateComponent } from './shared/decorator';
+export function applyStrategy(componentType, strategy) {
+    _bindComponentToEngine(componentType, {
+        onCreate(component) {
+            strategy(getStrategyDevKit(component));
+        },
+    });
+}
+export function _bindComponentToEngine(componentType, { onCreate }) {
+    decorateComponent(componentType, {
+        onCreate(component, changeDetectionFns) {
+            getEngine(component).setChangeDetectionFns(changeDetectionFns);
+            onCreate(component);
+        },
+        onInit(component) {
+            getEngine(component).markInitialized();
+        },
+        onDestroy(component) {
+            getEngine(component).markDestroyed();
+        },
+        onPropertyDeclare(component, property, value) {
+            getEngine(component).setProperty(property, value);
+        },
+        onPropertyGet(component, property) {
+            return getEngine(component).getProperty(property);
+        },
+        onPropertySet(component, property, value) {
+            getEngine(component).setProperty(property, value);
+        },
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/core/change-detection-fns.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhbmdlLWRldGVjdGlvbi1mbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9taWNyb3dhdmUvc3JjL2xpYi9jb3JlL2NoYW5nZS1kZXRlY3Rpb24tZm5zLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEFuIGFsdGVybmF0aXZlIHRvIENoYW5nZURldGVjdG9yUmVmIHRvIHN0YXkgbG9vc2VseSBjb3VwbGVkLlxuICogUGx1cywgdGhpcyBmdW5jdGlvbnMgY2FuIGJlIGRlc3RydWN0dXJlZCBhcyB0aGV5IGRvbid0IHVzZSBgdGhpc2AuXG4gKiBMZXQncyB0cnkgdG8gcmVkdWNlIHRoZSBzdXJmYWNlIGFuZCBub3QgZXhwb3NlIGFsbCBmdW5jdGlvbnNcbiAqIGlmIHdlIGRvbid0IG5lZWQgdGhlbS5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBDaGFuZ2VEZXRlY3Rpb25GbnMge1xuICBkZXRhY2goKTogdm9pZDtcbiAgZGV0ZWN0Q2hhbmdlcygpOiB2b2lkO1xufVxuIl19

package/esm2020/lib/core/engine.mjs

@@ -0,0 +1,65 @@
+import { BehaviorSubject, map, mapTo, ReplaySubject, take, } from 'rxjs';
+/**
+ * This should stay decoupled from Angular.
+ *
+ * @param component an instance of anything
+ * @returns an set of methods and observables that respectively
+ * control and represent the state of the object.
+ */
+export function getEngine(component) {
+    /* Memoize engine. */
+    const engine = component[_ENGINE_SYMBOL];
+    if (engine != null) {
+        return engine;
+    }
+    const destroyed$ = new ReplaySubject(1);
+    const initialized$ = new ReplaySubject(1);
+    const state$ = new BehaviorSubject({});
+    let changeDetectionFns;
+    return (component[_ENGINE_SYMBOL] = {
+        destroyed$: destroyed$.pipe(take(1)),
+        initialized$: initialized$.pipe(take(1)),
+        changed$: state$.pipe(mapTo(undefined)),
+        detach() {
+            changeDetectionFns.detach();
+        },
+        detectChanges() {
+            changeDetectionFns.detectChanges();
+        },
+        markDestroyed() {
+            destroyed$.next();
+        },
+        markInitialized() {
+            initialized$.next();
+        },
+        setChangeDetectionFns(_changeDetectionFns) {
+            changeDetectionFns = _changeDetectionFns;
+        },
+        getProperty(property) {
+            return state$.value[property];
+        },
+        setProperty(property, value) {
+            /* Don't set value if it didn't change.
+             * This is more performant than `distinctUntilChanged` all over the place. */
+            if (state$.value[property] === value) {
+                return;
+            }
+            state$.next({ ...state$.value, [property]: value });
+        },
+        watchProperty(property) {
+            return state$.pipe(map((state) => state[property]));
+        },
+    });
+}
+export const _ENGINE_SYMBOL = Symbol('MicrowaveEngine');
+export function _getPropertySubject(subjectsMap, property) {
+    let subject = subjectsMap.get(property);
+    if (subject == null) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        subject = new BehaviorSubject(undefined);
+        subjectsMap.set(property, subject);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return subject;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/devkit.mjs

@@ -0,0 +1,6 @@
+import { getEngine } from './core/engine';
+export function getStrategyDevKit(component) {
+    const { changed$, destroyed$, initialized$, detach, detectChanges } = getEngine(component);
+    return { changed$, destroyed$, initialized$, detach, detectChanges };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGV2a2l0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbWljcm93YXZlL3NyYy9saWIvZGV2a2l0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQStCLE1BQU0sZUFBZSxDQUFDO0FBRXZFLE1BQU0sVUFBVSxpQkFBaUIsQ0FDL0IsU0FBMkI7SUFFM0IsTUFBTSxFQUFFLFFBQVEsRUFBRSxVQUFVLEVBQUUsWUFBWSxFQUFFLE1BQU0sRUFBRSxhQUFhLEVBQUUsR0FDakUsU0FBUyxDQUFDLFNBQVMsQ0FBQyxDQUFDO0lBQ3ZCLE9BQU8sRUFBRSxRQUFRLEVBQUUsVUFBVSxFQUFFLFlBQVksRUFBRSxNQUFNLEVBQUUsYUFBYSxFQUFFLENBQUM7QUFDdkUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGdldEVuZ2luZSwgTWljcm93YXZlZCwgTWljcm93YXZlRW5naW5lIH0gZnJvbSAnLi9jb3JlL2VuZ2luZSc7XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRTdHJhdGVneURldktpdDxULCBLIGV4dGVuZHMga2V5b2YgVCA9IGtleW9mIFQ+KFxuICBjb21wb25lbnQ6IE1pY3Jvd2F2ZWQ8VCwgSz5cbik6IFN0cmF0ZWd5RGV2S2l0PFQsIEs+IHtcbiAgY29uc3QgeyBjaGFuZ2VkJCwgZGVzdHJveWVkJCwgaW5pdGlhbGl6ZWQkLCBkZXRhY2gsIGRldGVjdENoYW5nZXMgfSA9XG4gICAgZ2V0RW5naW5lKGNvbXBvbmVudCk7XG4gIHJldHVybiB7IGNoYW5nZWQkLCBkZXN0cm95ZWQkLCBpbml0aWFsaXplZCQsIGRldGFjaCwgZGV0ZWN0Q2hhbmdlcyB9O1xufVxuXG5leHBvcnQgdHlwZSBTdHJhdGVneURldktpdDxULCBLIGV4dGVuZHMga2V5b2YgVCA9IGtleW9mIFQ+ID0gUGljazxcbiAgTWljcm93YXZlRW5naW5lPFQsIEs+LFxuICAnY2hhbmdlZCQnIHwgJ2Rlc3Ryb3llZCQnIHwgJ2luaXRpYWxpemVkJCcgfCAnZGV0YWNoJyB8ICdkZXRlY3RDaGFuZ2VzJ1xuPjtcblxuZXhwb3J0IHR5cGUgU3RyYXRlZ3k8VD4gPSAoc3RyYXRlZ3lEZXZLaXQ6IFN0cmF0ZWd5RGV2S2l0PFQ+KSA9PiB2b2lkO1xuIl19

package/esm2020/lib/microwave.mjs

@@ -0,0 +1,14 @@
+import { takeUntil } from 'rxjs';
+import { applyStrategy } from './apply-strategy';
+import { getEngine } from './core/engine';
+import { asapStrategy } from './strategies/asap';
+export function Microwave({ strategy = asapStrategy } = {}) {
+    return function MicrowaveDecorator(componentType) {
+        applyStrategy(componentType, strategy);
+    };
+}
+export function watch(component, property) {
+    const { destroyed$, watchProperty } = getEngine(component);
+    return watchProperty(property).pipe(takeUntil(destroyed$));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWljcm93YXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbWljcm93YXZlL3NyYy9saWIvbWljcm93YXZlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBYyxTQUFTLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFDN0MsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ2pELE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFFMUMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLG1CQUFtQixDQUFDO0FBRWpELE1BQU0sVUFBVSxTQUFTLENBQUMsRUFBRSxRQUFRLEdBQUcsWUFBWSxFQUFFLEdBQUcsRUFBRTtJQUN4RCxPQUFPLFNBQVMsa0JBQWtCLENBQUksYUFBa0M7UUFDdEUsYUFBYSxDQUFDLGFBQWEsRUFBRSxRQUFRLENBQUMsQ0FBQztJQUN6QyxDQUFDLENBQUM7QUFDSixDQUFDO0FBRUQsTUFBTSxVQUFVLEtBQUssQ0FDbkIsU0FBWSxFQUNaLFFBQVc7SUFFWCxNQUFNLEVBQUUsVUFBVSxFQUFFLGFBQWEsRUFBRSxHQUFHLFNBQVMsQ0FBQyxTQUFTLENBQUMsQ0FBQztJQUMzRCxPQUFPLGFBQWEsQ0FBQyxRQUFRLENBQUMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUM7QUFDN0QsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE9ic2VydmFibGUsIHRha2VVbnRpbCB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgYXBwbHlTdHJhdGVneSB9IGZyb20gJy4vYXBwbHktc3RyYXRlZ3knO1xuaW1wb3J0IHsgZ2V0RW5naW5lIH0gZnJvbSAnLi9jb3JlL2VuZ2luZSc7XG5pbXBvcnQgeyBJdnlDb21wb25lbnRUeXBlIH0gZnJvbSAnLi9zaGFyZWQvZGVjb3JhdG9yJztcbmltcG9ydCB7IGFzYXBTdHJhdGVneSB9IGZyb20gJy4vc3RyYXRlZ2llcy9hc2FwJztcblxuZXhwb3J0IGZ1bmN0aW9uIE1pY3Jvd2F2ZSh7IHN0cmF0ZWd5ID0gYXNhcFN0cmF0ZWd5IH0gPSB7fSkge1xuICByZXR1cm4gZnVuY3Rpb24gTWljcm93YXZlRGVjb3JhdG9yPFQ+KGNvbXBvbmVudFR5cGU6IEl2eUNvbXBvbmVudFR5cGU8VD4pIHtcbiAgICBhcHBseVN0cmF0ZWd5KGNvbXBvbmVudFR5cGUsIHN0cmF0ZWd5KTtcbiAgfTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIHdhdGNoPFQsIEsgZXh0ZW5kcyBrZXlvZiBUID0ga2V5b2YgVD4oXG4gIGNvbXBvbmVudDogVCxcbiAgcHJvcGVydHk6IEtcbik6IE9ic2VydmFibGU8VFtLXSB8IHVuZGVmaW5lZD4ge1xuICBjb25zdCB7IGRlc3Ryb3llZCQsIHdhdGNoUHJvcGVydHkgfSA9IGdldEVuZ2luZShjb21wb25lbnQpO1xuICByZXR1cm4gd2F0Y2hQcm9wZXJ0eShwcm9wZXJ0eSkucGlwZSh0YWtlVW50aWwoZGVzdHJveWVkJCkpO1xufVxuIl19

package/esm2020/lib/shared/decorator.mjs

@@ -0,0 +1,89 @@
+import { ChangeDetectorRef, ɵɵdirectiveInject } from '@angular/core';
+/**
+ * Decorate Angular components with custom hooks.
+ *
+ * @param componentType the component class to decorate.
+ * @param hooks
+ */
+export function decorateComponent(componentType, hooks) {
+    const { onCreate, onInit, onDestroy, onPropertyDeclare, onPropertyGet, onPropertySet, } = hooks;
+    if (!componentType.ɵfac) {
+        throw new Error(`${componentType.name} is either not a component or not compiled.`);
+    }
+    /**
+     * Override component factory.
+     */
+    const factory = _decorate(componentType.ɵfac, 
+    /*
+     * Override getters & setters.
+     */
+    (factoryFn) => () => {
+        /* Grab change detector to control it. */
+        const cdr = ɵɵdirectiveInject(ChangeDetectorRef);
+        const component = factoryFn();
+        /**
+         * Notify about creation.
+         */
+        onCreate(component, {
+            detach() {
+                cdr.detach();
+            },
+            detectChanges() {
+                cdr.detectChanges();
+            },
+        });
+        /**
+         * This will only list initialized properties.
+         * That's the reason why all properties should be initialized
+         * when using Microwave.
+         */
+        for (const property of Object.getOwnPropertyNames(component)) {
+            /**
+             * Notify when property is discovered.
+             */
+            onPropertyDeclare(component, property, component[property]);
+            Object.defineProperty(component, property, {
+                set(value) {
+                    /**
+                     * Call setter.
+                     */
+                    onPropertySet(component, property, value);
+                },
+                get() {
+                    /**
+                     * Call getter.
+                     */
+                    return onPropertyGet(component, property);
+                },
+            });
+        }
+        return component;
+    });
+    /**
+     * Override factory with the newly decorated one.
+     */
+    Object.defineProperty(componentType, 'ɵfac', {
+        get() {
+            return factory;
+        },
+    });
+    /**
+     * Link hooks.
+     */
+    _spyOnMethod(componentType, 'ngOnInit', onInit);
+    _spyOnMethod(componentType, 'ngOnDestroy', onDestroy);
+}
+export function _spyOnMethod(klass, methodName, callback) {
+    const proto = klass.prototype;
+    proto[methodName] = _decorate(proto[methodName], (wrappedMethod) => {
+        return function () {
+            callback(this);
+            return wrappedMethod?.bind(this)?.();
+        };
+    });
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function _decorate(fn, decorator) {
+    return decorator(fn);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decorator.js","sourceRoot":"","sources":["../../../../../../packages/microwave/src/lib/shared/decorator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAQ,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAG3E;;;;;GAKG;AACH,MAAM,UAAU,iBAAiB,CAC/B,aAAkC,EAClC,KAAwB;IAExB,MAAM,EACJ,QAAQ,EACR,MAAM,EACN,SAAS,EACT,iBAAiB,EACjB,aAAa,EACb,aAAa,GACd,GAAG,KAAK,CAAC;IAEV,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE;QACvB,MAAM,IAAI,KAAK,CACb,GAAG,aAAa,CAAC,IAAI,6CAA6C,CACnE,CAAC;KACH;IAED;;OAEG;IACH,MAAM,OAAO,GAAG,SAAS,CACvB,aAAa,CAAC,IAAI;IAClB;;OAEG;IACH,CAAC,SAAkB,EAAE,EAAE,CAAC,GAAG,EAAE;QAC3B,yCAAyC;QACzC,MAAM,GAAG,GAAG,iBAAiB,CAAC,iBAAiB,CAAC,CAAC;QAEjD,MAAM,SAAS,GAAG,SAAS,EAAE,CAAC;QAE9B;;WAEG;QACH,QAAQ,CAAC,SAAS,EAAE;YAClB,MAAM;gBACJ,GAAG,CAAC,MAAM,EAAE,CAAC;YACf,CAAC;YACD,aAAa;gBACX,GAAG,CAAC,aAAa,EAAE,CAAC;YACtB,CAAC;SACF,CAAC,CAAC;QAEH;;;;WAIG;QACH,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,mBAAmB,CAC/C,SAAS,CACE,EAAE;YACb;;eAEG;YACH,iBAAiB,CAAC,SAAS,EAAE,QAAQ,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC;YAE5D,MAAM,CAAC,cAAc,CAAC,SAAS,EAAE,QAAQ,EAAE;gBACzC,GAAG,CAAC,KAAK;oBACP;;uBAEG;oBACH,aAAa,CAAC,SAAS,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;gBAC5C,CAAC;gBACD,GAAG;oBACD;;uBAEG;oBACH,OAAO,aAAa,CAAC,SAAS,EAAE,QAAQ,CAAC,CAAC;gBAC5C,CAAC;aACF,CAAC,CAAC;SACJ;QAED,OAAO,SAAS,CAAC;IACnB,CAAC,CACF,CAAC;IAEF;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,aAAa,EAAE,MAAM,EAAE;QAC3C,GAAG;YACD,OAAO,OAAO,CAAC;QACjB,CAAC;KACF,CAAC,CAAC;IAEH;;OAEG;IACH,YAAY,CAAC,aAAa,EAAE,UAAU,EAAE,MAAM,CAAC,CAAC;IAChD,YAAY,CAAC,aAAa,EAAE,aAAa,EAAE,SAAS,CAAC,CAAC;AACxD,CAAC;AA6CD,MAAM,UAAU,YAAY,CAC1B,KAAc,EACd,UAAkB,EAClB,QAA+B;IAE/B,MAAM,KAAK,GAAG,KAAK,CAAC,SAAS,CAAC;IAC9B,KAAK,CAAC,UAAU,CAAC,GAAG,SAAS,CAC3B,KAAK,CAAC,UAAU,CAAC,EACjB,CAAC,aAAyB,EAAE,EAAE;QAC5B,OAAO;YACL,QAAQ,CAAC,IAAI,CAAC,CAAC;YACf,OAAO,aAAa,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;QACvC,CAAC,CAAC;IACJ,CAAC,CACF,CAAC;AACJ,CAAC;AAED,8DAA8D;AAC9D,MAAM,UAAU,SAAS,CACvB,EAAK,EACL,SAAuB;IAEvB,OAAO,SAAS,CAAC,EAAE,CAAC,CAAC;AACvB,CAAC","sourcesContent":["import { ChangeDetectorRef, Type, ɵɵdirectiveInject } from '@angular/core';\nimport { ChangeDetectionFns } from '../core/change-detection-fns';\n\n/**\n * Decorate Angular components with custom hooks.\n *\n * @param componentType the component class to decorate.\n * @param hooks\n */\nexport function decorateComponent<T, K extends keyof T = keyof T>(\n  componentType: IvyComponentType<T>,\n  hooks: DecoratorHooks<T>\n) {\n  const {\n    onCreate,\n    onInit,\n    onDestroy,\n    onPropertyDeclare,\n    onPropertyGet,\n    onPropertySet,\n  } = hooks;\n\n  if (!componentType.ɵfac) {\n    throw new Error(\n      `${componentType.name} is either not a component or not compiled.`\n    );\n  }\n\n  /**\n   * Override component factory.\n   */\n  const factory = _decorate(\n    componentType.ɵfac,\n    /*\n     * Override getters & setters.\n     */\n    (factoryFn: () => T) => () => {\n      /* Grab change detector to control it. */\n      const cdr = ɵɵdirectiveInject(ChangeDetectorRef);\n\n      const component = factoryFn();\n\n      /**\n       * Notify about creation.\n       */\n      onCreate(component, {\n        detach() {\n          cdr.detach();\n        },\n        detectChanges() {\n          cdr.detectChanges();\n        },\n      });\n\n      /**\n       * This will only list initialized properties.\n       * That's the reason why all properties should be initialized\n       * when using Microwave.\n       */\n      for (const property of Object.getOwnPropertyNames(\n        component\n      ) as Array<K>) {\n        /**\n         * Notify when property is discovered.\n         */\n        onPropertyDeclare(component, property, component[property]);\n\n        Object.defineProperty(component, property, {\n          set(value) {\n            /**\n             * Call setter.\n             */\n            onPropertySet(component, property, value);\n          },\n          get() {\n            /**\n             * Call getter.\n             */\n            return onPropertyGet(component, property);\n          },\n        });\n      }\n\n      return component;\n    }\n  );\n\n  /**\n   * Override factory with the newly decorated one.\n   */\n  Object.defineProperty(componentType, 'ɵfac', {\n    get() {\n      return factory;\n    },\n  });\n\n  /**\n   * Link hooks.\n   */\n  _spyOnMethod(componentType, 'ngOnInit', onInit);\n  _spyOnMethod(componentType, 'ngOnDestroy', onDestroy);\n}\n\nexport interface DecoratorHooks<T, K extends keyof T = keyof T> {\n  /**\n   * Hook called when a new component is created.\n   *\n   * @param component the created component.\n   * @param args change detection functions for controlling change detection.\n   */\n  onCreate(component: T, args: ChangeDetectionFns): void;\n\n  /**\n   * Hook called when a new component is initialized.\n   *\n   * @param component the created component.\n   */\n  onInit(component: T): void;\n\n  /**\n   * Hook called just before the real ngOnDestroy (if implemented) is called.\n   */\n  onDestroy(component: T): void;\n\n  /**\n   * Hook called when a property is discovered.\n   * This is the opportunity to grab the initial value before\n   * the property is replaced by getters and setters.\n   */\n  onPropertyDeclare(component: T, property: K, value: T[K]): void;\n\n  /**\n   * Hook called to retrieve a property.\n   */\n  onPropertyGet(component: T, property: K): T[K] | undefined;\n\n  /**\n   * Hook called to set a property.\n   */\n  onPropertySet(component: T, property: K, value: T[K]): void;\n}\n\nexport interface IvyComponentType<T> extends Type<T> {\n  ɵfac?: () => T;\n}\n\nexport function _spyOnMethod<T>(\n  klass: Type<T>,\n  methodName: string,\n  callback: (instance: T) => void\n) {\n  const proto = klass.prototype;\n  proto[methodName] = _decorate(\n    proto[methodName],\n    (wrappedMethod: () => void) => {\n      return function (this: T) {\n        callback(this);\n        return wrappedMethod?.bind(this)?.();\n      };\n    }\n  );\n}\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport function _decorate<F extends (...args: any[]) => any>(\n  fn: F,\n  decorator: (fn: F) => F\n) {\n  return decorator(fn);\n}\n"]}

package/esm2020/lib/strategies/asap.mjs

@@ -0,0 +1,9 @@
+import { audit } from 'rxjs';
+import { createLocalStrategy } from './local';
+/**
+ * A strategy that coalesces changes using microtask scheduling.
+ */
+export const asapStrategy = createLocalStrategy({
+    coalescer: audit(() => Promise.resolve()),
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNhcC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL21pY3Jvd2F2ZS9zcmMvbGliL3N0cmF0ZWdpZXMvYXNhcC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBRTdCLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUU5Qzs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLFlBQVksR0FBc0IsbUJBQW1CLENBQUM7SUFDakUsU0FBUyxFQUFFLEtBQUssQ0FBQyxHQUFHLEVBQUUsQ0FBQyxPQUFPLENBQUMsT0FBTyxFQUFFLENBQUM7Q0FDMUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgYXVkaXQgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IFN0cmF0ZWd5IH0gZnJvbSAnLi4vZGV2a2l0JztcbmltcG9ydCB7IGNyZWF0ZUxvY2FsU3RyYXRlZ3kgfSBmcm9tICcuL2xvY2FsJztcblxuLyoqXG4gKiBBIHN0cmF0ZWd5IHRoYXQgY29hbGVzY2VzIGNoYW5nZXMgdXNpbmcgbWljcm90YXNrIHNjaGVkdWxpbmcuXG4gKi9cbmV4cG9ydCBjb25zdCBhc2FwU3RyYXRlZ3k6IFN0cmF0ZWd5PHVua25vd24+ID0gY3JlYXRlTG9jYWxTdHJhdGVneSh7XG4gIGNvYWxlc2NlcjogYXVkaXQoKCkgPT4gUHJvbWlzZS5yZXNvbHZlKCkpLFxufSk7XG4iXX0=

package/esm2020/lib/strategies/async.mjs

@@ -0,0 +1,9 @@
+import { audit, timer } from 'rxjs';
+import { createLocalStrategy } from './local';
+/**
+ * A strategy that coalesces changes using macrotask scheduling.
+ */
+export const asyncStrategy = createLocalStrategy({
+    coalescer: audit(() => timer(0)),
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXN5bmMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9taWNyb3dhdmUvc3JjL2xpYi9zdHJhdGVnaWVzL2FzeW5jLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxLQUFLLEVBQUUsS0FBSyxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBRXBDLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUU5Qzs7R0FFRztBQUNILE1BQU0sQ0FBQyxNQUFNLGFBQWEsR0FBc0IsbUJBQW1CLENBQUM7SUFDbEUsU0FBUyxFQUFFLEtBQUssQ0FBQyxHQUFHLEVBQUUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUM7Q0FDakMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgYXVkaXQsIHRpbWVyIH0gZnJvbSAncnhqcyc7XG5pbXBvcnQgeyBTdHJhdGVneSB9IGZyb20gJy4uL2RldmtpdCc7XG5pbXBvcnQgeyBjcmVhdGVMb2NhbFN0cmF0ZWd5IH0gZnJvbSAnLi9sb2NhbCc7XG5cbi8qKlxuICogQSBzdHJhdGVneSB0aGF0IGNvYWxlc2NlcyBjaGFuZ2VzIHVzaW5nIG1hY3JvdGFzayBzY2hlZHVsaW5nLlxuICovXG5leHBvcnQgY29uc3QgYXN5bmNTdHJhdGVneTogU3RyYXRlZ3k8dW5rbm93bj4gPSBjcmVhdGVMb2NhbFN0cmF0ZWd5KHtcbiAgY29hbGVzY2VyOiBhdWRpdCgoKSA9PiB0aW1lcigwKSksXG59KTtcbiJdfQ==

package/esm2020/lib/strategies/index.mjs

@@ -0,0 +1,6 @@
+export { createLocalStrategy } from './local';
+export { syncStrategy } from './sync';
+export { asapStrategy } from './asap';
+export { asyncStrategy } from './async';
+export { rafStrategy } from './raf';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9taWNyb3dhdmUvc3JjL2xpYi9zdHJhdGVnaWVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxtQkFBbUIsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUM5QyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sUUFBUSxDQUFDO0FBQ3RDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFDdEMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLFNBQVMsQ0FBQztBQUN4QyxPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sT0FBTyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgY3JlYXRlTG9jYWxTdHJhdGVneSB9IGZyb20gJy4vbG9jYWwnO1xuZXhwb3J0IHsgc3luY1N0cmF0ZWd5IH0gZnJvbSAnLi9zeW5jJztcbmV4cG9ydCB7IGFzYXBTdHJhdGVneSB9IGZyb20gJy4vYXNhcCc7XG5leHBvcnQgeyBhc3luY1N0cmF0ZWd5IH0gZnJvbSAnLi9hc3luYyc7XG5leHBvcnQgeyByYWZTdHJhdGVneSB9IGZyb20gJy4vcmFmJztcbiJdfQ==

package/esm2020/lib/strategies/local.mjs

@@ -0,0 +1,26 @@
+import { concat, takeUntil } from 'rxjs';
+/**
+ * Creates a change detection strategy which is local to the component.
+ * It implements optional coalescing which can be customized using `coalescer` parameter.
+ *
+ * @example createLocalStrategy()
+ * @example createLocalStrategy({coalescer: audit(() => Promise.resolve())})
+ *
+ * @returns a strategy that can be used with Microwave decorator.
+ */
+export const createLocalStrategy = ({ coalescer, } = {}) => ({ initialized$, changed$, destroyed$, detach, detectChanges }) => {
+    /**
+     * Detach change detection as we want to take control.
+     */
+    detach();
+    /**
+     * Trigger change detection initially and on property changes.
+     * Coalesce through micro-tasks.
+     */
+    let source$ = concat(initialized$, changed$);
+    if (coalescer != null) {
+        source$ = source$.pipe(coalescer);
+    }
+    source$.pipe(takeUntil(destroyed$)).subscribe(() => detectChanges());
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibG9jYWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wYWNrYWdlcy9taWNyb3dhdmUvc3JjL2xpYi9zdHJhdGVnaWVzL2xvY2FsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQTRCLFNBQVMsRUFBRSxNQUFNLE1BQU0sQ0FBQztBQUduRTs7Ozs7Ozs7R0FRRztBQUNILE1BQU0sQ0FBQyxNQUFNLG1CQUFtQixHQUM5QixDQUFDLEVBQ0MsU0FBUyxNQUN5QyxFQUFFLEVBQXFCLEVBQUUsQ0FDN0UsQ0FBQyxFQUFFLFlBQVksRUFBRSxRQUFRLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRSxhQUFhLEVBQUUsRUFBRSxFQUFFO0lBQ2hFOztPQUVHO0lBQ0gsTUFBTSxFQUFFLENBQUM7SUFFVDs7O09BR0c7SUFDSCxJQUFJLE9BQU8sR0FBRyxNQUFNLENBQUMsWUFBWSxFQUFFLFFBQVEsQ0FBQyxDQUFDO0lBRTdDLElBQUksU0FBUyxJQUFJLElBQUksRUFBRTtRQUNyQixPQUFPLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztLQUNuQztJQUVELE9BQU8sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsU0FBUyxDQUFDLEdBQUcsRUFBRSxDQUFDLGFBQWEsRUFBRSxDQUFDLENBQUM7QUFDdkUsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY29uY2F0LCBNb25vVHlwZU9wZXJhdG9yRnVuY3Rpb24sIHRha2VVbnRpbCB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgU3RyYXRlZ3kgfSBmcm9tICcuLi9kZXZraXQnO1xuXG4vKipcbiAqIENyZWF0ZXMgYSBjaGFuZ2UgZGV0ZWN0aW9uIHN0cmF0ZWd5IHdoaWNoIGlzIGxvY2FsIHRvIHRoZSBjb21wb25lbnQuXG4gKiBJdCBpbXBsZW1lbnRzIG9wdGlvbmFsIGNvYWxlc2Npbmcgd2hpY2ggY2FuIGJlIGN1c3RvbWl6ZWQgdXNpbmcgYGNvYWxlc2NlcmAgcGFyYW1ldGVyLlxuICpcbiAqIEBleGFtcGxlIGNyZWF0ZUxvY2FsU3RyYXRlZ3koKVxuICogQGV4YW1wbGUgY3JlYXRlTG9jYWxTdHJhdGVneSh7Y29hbGVzY2VyOiBhdWRpdCgoKSA9PiBQcm9taXNlLnJlc29sdmUoKSl9KVxuICpcbiAqIEByZXR1cm5zIGEgc3RyYXRlZ3kgdGhhdCBjYW4gYmUgdXNlZCB3aXRoIE1pY3Jvd2F2ZSBkZWNvcmF0b3IuXG4gKi9cbmV4cG9ydCBjb25zdCBjcmVhdGVMb2NhbFN0cmF0ZWd5ID1cbiAgKHtcbiAgICBjb2FsZXNjZXIsXG4gIH06IHsgY29hbGVzY2VyPzogTW9ub1R5cGVPcGVyYXRvckZ1bmN0aW9uPHZvaWQ+IH0gPSB7fSk6IFN0cmF0ZWd5PHVua25vd24+ID0+XG4gICh7IGluaXRpYWxpemVkJCwgY2hhbmdlZCQsIGRlc3Ryb3llZCQsIGRldGFjaCwgZGV0ZWN0Q2hhbmdlcyB9KSA9PiB7XG4gICAgLyoqXG4gICAgICogRGV0YWNoIGNoYW5nZSBkZXRlY3Rpb24gYXMgd2Ugd2FudCB0byB0YWtlIGNvbnRyb2wuXG4gICAgICovXG4gICAgZGV0YWNoKCk7XG5cbiAgICAvKipcbiAgICAgKiBUcmlnZ2VyIGNoYW5nZSBkZXRlY3Rpb24gaW5pdGlhbGx5IGFuZCBvbiBwcm9wZXJ0eSBjaGFuZ2VzLlxuICAgICAqIENvYWxlc2NlIHRocm91Z2ggbWljcm8tdGFza3MuXG4gICAgICovXG4gICAgbGV0IHNvdXJjZSQgPSBjb25jYXQoaW5pdGlhbGl6ZWQkLCBjaGFuZ2VkJCk7XG5cbiAgICBpZiAoY29hbGVzY2VyICE9IG51bGwpIHtcbiAgICAgIHNvdXJjZSQgPSBzb3VyY2UkLnBpcGUoY29hbGVzY2VyKTtcbiAgICB9XG5cbiAgICBzb3VyY2UkLnBpcGUodGFrZVVudGlsKGRlc3Ryb3llZCQpKS5zdWJzY3JpYmUoKCkgPT4gZGV0ZWN0Q2hhbmdlcygpKTtcbiAgfTtcbiJdfQ==

package/esm2020/lib/strategies/raf.mjs

@@ -0,0 +1,9 @@
+import { audit, animationFrames } from 'rxjs';
+import { createLocalStrategy } from './local';
+/**
+ * A strategy that coalesces changes using requestAnimationFrame scheduler.
+ */
+export const rafStrategy = createLocalStrategy({
+    coalescer: audit(() => animationFrames()),
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmFmLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvbWljcm93YXZlL3NyYy9saWIvc3RyYXRlZ2llcy9yYWYudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLEtBQUssRUFBRSxlQUFlLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFFOUMsT0FBTyxFQUFFLG1CQUFtQixFQUFFLE1BQU0sU0FBUyxDQUFDO0FBRTlDOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUFzQixtQkFBbUIsQ0FBQztJQUNoRSxTQUFTLEVBQUUsS0FBSyxDQUFDLEdBQUcsRUFBRSxDQUFDLGVBQWUsRUFBRSxDQUFDO0NBQzFDLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGF1ZGl0LCBhbmltYXRpb25GcmFtZXMgfSBmcm9tICdyeGpzJztcbmltcG9ydCB7IFN0cmF0ZWd5IH0gZnJvbSAnLi4vZGV2a2l0JztcbmltcG9ydCB7IGNyZWF0ZUxvY2FsU3RyYXRlZ3kgfSBmcm9tICcuL2xvY2FsJztcblxuLyoqXG4gKiBBIHN0cmF0ZWd5IHRoYXQgY29hbGVzY2VzIGNoYW5nZXMgdXNpbmcgcmVxdWVzdEFuaW1hdGlvbkZyYW1lIHNjaGVkdWxlci5cbiAqL1xuZXhwb3J0IGNvbnN0IHJhZlN0cmF0ZWd5OiBTdHJhdGVneTx1bmtub3duPiA9IGNyZWF0ZUxvY2FsU3RyYXRlZ3koe1xuICBjb2FsZXNjZXI6IGF1ZGl0KCgpID0+IGFuaW1hdGlvbkZyYW1lcygpKSxcbn0pO1xuIl19

package/esm2020/lib/strategies/sync.mjs

@@ -0,0 +1,3 @@
+import { createLocalStrategy } from './local';
+export const syncStrategy = createLocalStrategy();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3luYy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL21pY3Jvd2F2ZS9zcmMvbGliL3N0cmF0ZWdpZXMvc3luYy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxTQUFTLENBQUM7QUFHOUMsTUFBTSxDQUFDLE1BQU0sWUFBWSxHQUFzQixtQkFBbUIsRUFBRSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgY3JlYXRlTG9jYWxTdHJhdGVneSB9IGZyb20gJy4vbG9jYWwnO1xuaW1wb3J0IHsgU3RyYXRlZ3kgfSBmcm9tICcuLi9kZXZraXQnO1xuXG5leHBvcnQgY29uc3Qgc3luY1N0cmF0ZWd5OiBTdHJhdGVneTx1bmtub3duPiA9IGNyZWF0ZUxvY2FsU3RyYXRlZ3koKTtcbiJdfQ==