@runopencode/rx-stencil 0.4.3 → 0.5.0

package/dist/{esm/set-property-CpZKE-Xu.js → cjs/index-Dssn3hdS.js}

@@ -1,4 +1,4 @@
-import { f as forceUpdate } from './index-BIBww8qU.js';
+'use strict';
 
 var cjs = {};
 
@@ -9458,63 +9458,4 @@ function requireCjs () {
 
 var cjsExports = /*@__PURE__*/ requireCjs();
 
-/**
- * Returns property descriptor for the given property of the component.
- *
- * {@internal}
- */
-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;
-}
-
-/**
- * Returns an observable that emits property value when the component property value changes.
- */
-function propertyObservable(cmp, property) {
-    let subjectProperty = `__rx__subject_for_property__${property}__`;
-    if (!cmp[subjectProperty]) {
-        let descriptor = getPropertyDescriptor(cmp, property);
-        let previousSetter = descriptor.set;
-        let previousGetter = descriptor.get;
-        // we have to invoke previous getter on component instance to get the current value
-        let currentValue = undefined !== previousGetter ? previousGetter.call(cmp) : descriptor.value;
-        let subject = new cjsExports.BehaviorSubject(currentValue);
-        descriptor.set = function (value) {
-            if (previousSetter) {
-                previousSetter.call(this, value);
-            }
-            subject.next(value);
-        };
-        Object.defineProperty(cmp, property, descriptor);
-        cmp[subjectProperty] = subject;
-    }
-    return cmp[subjectProperty]
-        .asObservable()
-        .pipe(cjsExports.distinctUntilChanged());
-}
-
-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));
-    };
-}
-
-export { cjsExports as c, getPropertyDescriptor as g, propertyObservable as p, setProperty as s };
+exports.cjsExports = cjsExports;

package/dist/cjs/index.cjs.js

@@ -1,291 +1,327 @@
 'use strict';
 
-var index = require('./index-CbERigo8.js');
-var setProperty = require('./set-property-BZHuI0P5.js');
+var index = require('./index-DWhjpI-K.js');
+var index$1 = require('./index-Dssn3hdS.js');
+var stencil = require('./stencil-uD4ZIy1h.js');
+var mutationObservable = require('./mutation-observable-qY7nC854.js');
+var scheduleRender = require('./schedule-render-DG4hFv5E.js');
+var propertiesObservable = require('./properties-observable-DXbVBslA.js');
+var propertyObservable = require('./property-observable-CPp5WEjC.js');
+var untilDisconnected = require('./until-disconnected-BTCr-3q2.js');
+var setProperty = require('./set-property-C3KARzdl.js');
 
-function mutationObservable(target, options) {
-    return new setProperty.cjsExports.Observable((observer) => {
-        let mutation = new MutationObserver((mutations) => {
-            observer.next(mutations);
-        });
-        mutation.observe(target, options);
-        return () => {
-            mutation.disconnect();
+/**
+ * Operator that emits values from the source observable only
+ * while the component is connected to DOM.
+ *
+ * This can be useful for cases where you want to move components in and out of the DOM,
+ * but still want to receive values from an observable while the component is connected
+ * and react to them.
+ */
+function whileConnected(cmp, options) {
+    return (source) => {
+        let element = index.getElement(cmp);
+        let reemit = (options === null || options === void 0 ? void 0 : options.reemit) || false;
+        if (!reemit) {
+            return source.pipe(index$1.cjsExports.filter(() => element.isConnected));
+        }
+        let captured = false;
+        let last = undefined;
+        let reemiter = new index$1.cjsExports.Subject();
+        let previousConnectedCallback = cmp.connectedCallback;
+        cmp.connectedCallback = function () {
+            previousConnectedCallback === null || previousConnectedCallback === void 0 ? void 0 : previousConnectedCallback.call(this);
+            if (!captured) {
+                return;
+            }
+            reemiter.next(last);
+            captured = false;
+            last = undefined;
         };
-    });
+        return index$1.cjsExports.merge(reemiter, source.pipe(index$1.cjsExports.tap((value) => {
+            if (element.isConnected) {
+                return;
+            }
+            captured = true;
+            last = value;
+        }), index$1.cjsExports.filter(() => element.isConnected)));
+    };
 }
 
+function applyOperators(...args) {
+    let [observable, cmp, options] = args;
+    return applyOperatorsInternal(observable, cmp, options);
+}
 /**
- * Returns an observable that emits an array of values from the given properties.
+ * A TypeScript types hack to make the applyOperators function work
+ * with both ViewChild and ViewChildren options.
+ *
+ * @internal
  */
-function propertiesObservable(cmp, ...properties) {
-    if (0 === properties.length) {
-        throw new Error('At least one property must be specified.');
+function applyOperatorsInternal(observable, cmp, options) {
+    if (options === null || options === void 0 ? void 0 : options.whileConnected) {
+        observable = observable.pipe(whileConnected(cmp, {
+            reemit: true,
+        }));
     }
-    return setProperty.cjsExports.combineLatest(properties.map((property) => {
-        return setProperty.propertyObservable(cmp, property);
-    }));
+    if (options === null || options === void 0 ? void 0 : options.filter) {
+        observable = observable.pipe(true === options.filter
+            ? index$1.cjsExports.filter((value) => {
+                if (Array.isArray(value) && value.length > 0) {
+                    return true;
+                }
+                return !!value;
+            })
+            : index$1.cjsExports.filter(options.filter));
+    }
+    if (options === null || options === void 0 ? void 0 : options.cached) {
+        observable = observable.pipe(index$1.cjsExports.take(1));
+    }
+    return observable;
 }
 
-/**
- * Returns an observable that emits when the component render()
- * function is called. Value will be emitted after the next
- * microtask (next tick).
- */
-function renderObservable(cmp) {
-    if ('function' !== typeof cmp.render) {
-        throw new Error('Component does not have a render function.');
+let registries = new Map();
+class ValuesRegistry {
+    constructor() {
+        this._observables = new WeakMap();
+    }
+    has(element, property) {
+        return this._observables.has(element) && this._observables.get(element).has(property);
+    }
+    get(element, property) {
+        var _a, _b;
+        return (_b = (_a = this._observables.get(element)) === null || _a === void 0 ? void 0 : _a.get(property)) === null || _b === void 0 ? void 0 : _b[0];
+    }
+    set(element, property, observable, initial) {
+        this.delete(element, property);
+        if (!this._observables.has(element)) {
+            this._observables.set(element, new Map());
+        }
+        this._observables.get(element).set(property, [observable, initial, undefined]);
+        this._observables.get(element).get(property)[2] = observable.subscribe((value) => {
+            this._observables.get(element).get(property)[1] = value;
+        });
+    }
+    delete(element, property) {
+        if (this._observables.has(element) && this._observables.get(element).has(property)) {
+            let previous = this._observables.get(element).get(property)[2];
+            previous === null || previous === void 0 ? void 0 : previous.unsubscribe();
+            this._observables.get(element).delete(property);
+        }
+    }
+    value(element, property) {
+        var _a, _b;
+        return (_b = (_a = this._observables.get(element)) === null || _a === void 0 ? void 0 : _a.get(property)) === null || _b === void 0 ? void 0 : _b[1];
     }
-    return new setProperty.cjsExports.Observable((subscriber) => {
-        let previousRender = cmp.render;
-        cmp.render = function () {
-            Promise.resolve().then(() => {
-                subscriber.next();
-            });
-            return previousRender.call(this);
-        };
-        return () => {
-            cmp.render = previousRender;
-        };
-    });
+}
+function getRegistry(key) {
+    if (!registries.has(key)) {
+        registries.set(key, new ValuesRegistry());
+    }
+    return registries.get(key);
 }
 
-/**
- * Observe all sub nodes of the given node and notify
- * when any of them is removed and/or added.
- *
- * {@internal}
- */
-function observeSubNodes(target) {
-    return mutationObservable(target, {
-        subtree: true,
-        childList: true,
-    }).pipe(setProperty.cjsExports.filter((records) => {
-        for (let i = 0; i < records.length; i++) {
-            if ('childList' !== records[i].type) {
-                continue;
-            }
-            if (records[i].addedNodes.length || records[i].removedNodes.length) {
-                return true;
+function contentChildObservable(cmp, selector, options) {
+    let element = index.getElement(cmp);
+    let mutations = mutationObservable.observeSubtree(element).pipe(index$1.cjsExports.map(() => void 0), index$1.cjsExports.startWith(void 0));
+    options = Object.assign({ distinct: true }, options);
+    // In shadow DOM, we can just listen for the mutations and query the element directly.
+    if (stencil.usesShadowDom(cmp)) {
+        return mutations.pipe(index$1.cjsExports.map(() => element.querySelector(selector)), mutationObservable.distinctUntilElementChanged(options.distinct));
+    }
+    // When shadow DOM is emulated, we need to filter out elements that are part of the emulated view child.
+    return mutations.pipe(index$1.cjsExports.map(() => {
+        let candidates = Array.from(element.querySelectorAll(selector));
+        for (let i = 0; i < candidates.length; i++) {
+            let candidate = candidates[i];
+            if (!stencil.isEmulatedViewChild(candidate, element)) {
+                return candidate;
             }
         }
-        return false;
-    }), setProperty.cjsExports.map(() => {
-        /* noop */
-    }));
+        return null;
+    }), mutationObservable.distinctUntilElementChanged(options.distinct));
 }
-/**
- * Property decorator inspired by Angular's @ViewChild/@ContentChild.
- *
- * After each render, the decorated property will be set to the first element
- * matching the given selector. If no element is found, the property will be
- * set to null.
- */
-function QuerySelector(selector, options) {
-    return (target, property) => {
-        let descriptor = {
-            set: function () {
-                throw new Error(`Property "${property}" is read-only.`);
+
+function ContentChild(selector, options) {
+    return function (cmp, property) {
+        let connectedCallback = cmp.connectedCallback;
+        cmp.connectedCallback = function () {
+            connectedCallback === null || connectedCallback === void 0 ? void 0 : connectedCallback.call(this);
+        };
+        let descriptor = Object.getOwnPropertyDescriptor(cmp.prototype, property) || {
+            configurable: true,
+            enumerable: true,
+        };
+        delete descriptor['value'];
+        delete descriptor['writable'];
+        Object.defineProperty(cmp, property, Object.assign(Object.assign({}, descriptor), { set(_value) {
             },
-            get: function () {
-                let observableProperty = `__rx__query_selector__observable__shadow_root__${(options === null || options === void 0 ? void 0 : options.shadowRoot) ? 'yes' : 'no'}__mutation_observer__${(options === null || options === void 0 ? void 0 : options.mutationObserver) ? 'yes' : 'no'}__selector__${selector}__`;
-                if (!this[observableProperty]) {
-                    let root = (options === null || options === void 0 ? void 0 : options.shadowRoot) ? index.getElement(this).shadowRoot : index.getElement(this);
-                    let observable = (options === null || options === void 0 ? void 0 : options.mutationObserver) ? observeSubNodes(root) : renderObservable(this);
-                    this[observableProperty] = observable.pipe(setProperty.cjsExports.startWith(), setProperty.cjsExports.map(() => root.querySelector(selector)), setProperty.cjsExports.distinctUntilChanged(), setProperty.cjsExports.shareReplay(1));
+            get() {
+                let element = index.getElement(this);
+                let registry = getRegistry('@ContentChild');
+                if (!registry.has(element, property)) {
+                    let observable = contentChildObservable(this, selector, options);
+                    observable = applyOperators(observable, this, options);
+                    registry.set(element, property, observable);
                 }
-                return this[observableProperty];
-            },
-        };
-        Object.defineProperty(target, property, descriptor);
+                return registry.value(element, property);
+            } }));
     };
 }
 
-/**
- * Property decorator inspired by Angular's @ViewChild/@ContentChild.
- *
- * After each render, the decorated property will be set to the first element
- * matching the given selector. If no element is found, the property will be
- * set to null.
- */
-function QuerySelectorAll(selector, options) {
-    return (target, property) => {
-        let descriptor = {
-            set: function () {
-                throw new Error(`Property "${property}" is read-only.`);
+function contentChildrenObservable(cmp, selector, options) {
+    let element = index.getElement(cmp);
+    let mutations = mutationObservable.observeSubtree(element).pipe(index$1.cjsExports.map(() => void 0), index$1.cjsExports.startWith(void 0));
+    options = Object.assign({ distinct: true }, options);
+    // In shadow DOM, we can just listen for the mutations and query the element directly.
+    if (stencil.usesShadowDom(cmp)) {
+        return mutations.pipe(index$1.cjsExports.map(() => Array.from(element.querySelectorAll(selector))), mutationObservable.distinctUntilElementsChanged(options.distinct));
+    }
+    // When shadow DOM is emulated, we need to filter out elements that are part of the emulated view child.
+    return mutations.pipe(index$1.cjsExports.map(() => Array.from(element.querySelectorAll(selector)).filter((candidate) => !stencil.isEmulatedViewChild(candidate, element))), mutationObservable.distinctUntilElementsChanged(options.distinct));
+}
+
+function ContentChildren(selector, options) {
+    return function (cmp, property) {
+        let connectedCallback = cmp.connectedCallback;
+        cmp.connectedCallback = function () {
+            connectedCallback === null || connectedCallback === void 0 ? void 0 : connectedCallback.call(this);
+        };
+        let descriptor = Object.getOwnPropertyDescriptor(cmp.prototype, property) || {
+            configurable: true,
+            enumerable: true,
+        };
+        delete descriptor['value'];
+        delete descriptor['writable'];
+        Object.defineProperty(cmp, property, Object.assign(Object.assign({}, descriptor), { set(_value) {
             },
-            get: function () {
-                let observableProperty = `__rx__query_selector_all__observable__shadow_root__${(options === null || options === void 0 ? void 0 : options.shadowRoot) ? 'yes' : 'no'}__mutation_observer__${(options === null || options === void 0 ? void 0 : options.mutationObserver) ? 'yes' : 'no'}__selector__${selector}__`;
-                if (!this[observableProperty]) {
-                    let root = (options === null || options === void 0 ? void 0 : options.shadowRoot) ? index.getElement(this).shadowRoot : index.getElement(this);
-                    let observable = (options === null || options === void 0 ? void 0 : options.mutationObserver) ? observeSubNodes(root) : renderObservable(this);
-                    this[observableProperty] = observable.pipe(setProperty.cjsExports.startWith(), setProperty.cjsExports.map(() => Array.from(root.querySelectorAll(selector))), setProperty.cjsExports.distinctUntilChanged((previous, current) => {
-                        if (previous.length !== current.length) {
-                            return false;
-                        }
-                        for (let i = 0; i < previous.length; i++) {
-                            if (previous[i] !== current[i]) {
-                                return false;
-                            }
-                        }
-                        return true;
-                    }), setProperty.cjsExports.shareReplay(1));
+            get() {
+                let element = index.getElement(cmp);
+                let registry = getRegistry('@ContentChildren');
+                if (!registry.has(element, property)) {
+                    let observable = contentChildrenObservable(this, selector, options);
+                    observable = applyOperators(observable, this, options);
+                    registry.set(element, property, observable);
                 }
-                return this[observableProperty];
-            },
-        };
-        Object.defineProperty(target, property, descriptor);
+                return registry.value(element, property);
+            } }));
     };
 }
 
-/**
- * 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.
- */
-function scheduleRender(cmp, nextTick = true) {
-    return (source) => {
-        return source.pipe(setProperty.cjsExports.tap(() => {
-            if (!nextTick) {
-                index.forceUpdate(cmp);
-                return;
-            }
-            Promise.resolve().then(() => index.forceUpdate(cmp));
-        }));
+function ViewChild(selector, options) {
+    return function (cmp, property) {
+        let connectedCallback = cmp.connectedCallback;
+        cmp.connectedCallback = function () {
+            connectedCallback === null || connectedCallback === void 0 ? void 0 : connectedCallback.call(this);
+        };
+        let descriptor = Object.getOwnPropertyDescriptor(cmp.prototype, property) || {
+            configurable: true,
+            enumerable: true,
+        };
+        delete descriptor['value'];
+        delete descriptor['writable'];
+        Object.defineProperty(cmp, property, Object.assign(Object.assign({}, descriptor), { set(_value) {
+            },
+            get() {
+                let element = index.getElement(this);
+                let registry = getRegistry('@ViewChild');
+                if (!registry.has(element, property)) {
+                    let observable = mutationObservable.viewChildObservable(this, selector, options);
+                    observable = applyOperators(observable, this, options);
+                    registry.set(element, property, observable);
+                }
+                return registry.value(element, property);
+            } }));
     };
 }
 
-/**
- * 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).
- */
-function toProperty(cmp, property) {
-    // ensure that the property is defined on the component.
-    setProperty.getPropertyDescriptor(cmp, property);
-    // @ts-ignore
-    return (source) => {
-        return source.pipe(setProperty.cjsExports.tap((value) => {
-            cmp[property] = value;
-        }));
-    };
+function QuerySelector(selector, options) {
+    if ('content' === (options === null || options === void 0 ? void 0 : options.target)) {
+        return ContentChild(selector, options);
+    }
+    return ViewChild(selector, options);
 }
 
-/**
- * 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 setProperty.cjsExports.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) {
+function viewChildrenObservable(cmp, selector, options) {
     let element = index.getElement(cmp);
-    if (null === element.parentNode) {
-        throw new Error(`Component "${cmp.constructor.name}" is not within DOM.`);
+    let hostRef = stencil.getHostRef(cmp);
+    let rendered = mutationObservable.renderObservable(cmp);
+    options = Object.assign({ distinct: true }, options);
+    if ((hostRef.$renderCount$ || 0) > 0) {
+        rendered = rendered.pipe(index$1.cjsExports.startWith(void 0));
     }
-    return new setProperty.cjsExports.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);
+    // In shadow DOM, this is quite cheap, we can query only shadow DOM and skip the light DOM.
+    if (stencil.usesShadowDom(cmp)) {
+        return rendered.pipe(index$1.cjsExports.map(() => Array.from(element.shadowRoot.querySelectorAll(selector))), mutationObservable.distinctUntilElementsChanged(options.distinct));
+    }
+    // When shadow DOM is emulated, this is more expensive, we need to query light DOM and use elements
+    // which matches the selector, and it is not a child of any emulated slot node.
+    return rendered.pipe(index$1.cjsExports.map(() => Array.from(element.querySelectorAll(selector))), index$1.cjsExports.map((candidates) => candidates.filter((candidate) => stencil.isEmulatedViewChild(candidate, element))), mutationObservable.distinctUntilElementsChanged(options.distinct));
+}
+
+function ViewChildren(selector, options) {
+    return function (cmp, property) {
+        let connectedCallback = cmp.connectedCallback;
+        cmp.connectedCallback = function () {
+            connectedCallback === null || connectedCallback === void 0 ? void 0 : connectedCallback.call(this);
         };
-    });
-};
-/**
- * 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
-        }
+        let descriptor = Object.getOwnPropertyDescriptor(cmp.prototype, property) || {
+            configurable: true,
+            enumerable: true,
+        };
+        delete descriptor['value'];
+        delete descriptor['writable'];
+        Object.defineProperty(cmp, property, Object.assign(Object.assign({}, descriptor), { set(_value) {
+            },
+            get() {
+                let element = index.getElement(cmp);
+                let registry = getRegistry('@ViewChildren');
+                if (!registry.has(element, property)) {
+                    let observable = viewChildrenObservable(this, selector, options);
+                    observable = applyOperators(observable, this, options);
+                    registry.set(element, property, observable);
+                }
+                return registry.value(element, property);
+            } }));
+    };
+}
+
+function QuerySelectorAll(selector, options) {
+    if ('content' === (options === null || options === void 0 ? void 0 : options.target)) {
+        return ContentChildren(selector, options);
     }
-    throw new Error(`Could not create disconnect observable for component "${cmp.constructor.name}".`);
+    return ViewChildren(selector, options);
 }
+
 /**
- * Operator that unsubscribes from the source observable when
- * the component is disconnected from DOM.
+ * Use this function to tap into a value stream and flush value to
+ * component property.
  */
-function untilDisconnected(cmp) {
+function toProperty(cmp, property) {
     return (source) => {
-        if (!disconnectObservables.has(cmp)) {
-            createDisconnectObservable(cmp);
-        }
-        let disconnectObservable$ = disconnectObservables.get(cmp);
-        return source.pipe(setProperty.cjsExports.takeUntil(disconnectObservable$));
+        return source.pipe(index$1.cjsExports.tap((value) => {
+            cmp[property] = value;
+        }));
     };
 }
 
-exports.propertyObservable = setProperty.propertyObservable;
+exports.mutationObservable = mutationObservable.mutationObservable;
+exports.renderObservable = mutationObservable.renderObservable;
+exports.viewChildObservable = mutationObservable.viewChildObservable;
+exports.fromEvent = scheduleRender.fromEvent;
+exports.scheduleRender = scheduleRender.scheduleRender;
+exports.propertiesObservable = propertiesObservable.propertiesObservable;
+exports.propertyObservable = propertyObservable.propertyObservable;
+exports.untilDisconnected = untilDisconnected.untilDisconnected;
 exports.setProperty = setProperty.setProperty;
+exports.ContentChild = ContentChild;
+exports.ContentChildren = ContentChildren;
 exports.QuerySelector = QuerySelector;
 exports.QuerySelectorAll = QuerySelectorAll;
-exports.mutationObservable = mutationObservable;
-exports.propertiesObservable = propertiesObservable;
-exports.renderObservable = renderObservable;
-exports.scheduleRender = scheduleRender;
+exports.ViewChild = ViewChild;
+exports.ViewChildren = ViewChildren;
+exports.contentChildObservable = contentChildObservable;
+exports.contentChildrenObservable = contentChildrenObservable;
 exports.toProperty = toProperty;
-exports.untilDisconnected = untilDisconnected;
+exports.viewChildrenObservable = viewChildrenObservable;
+exports.whileConnected = whileConnected;