@angular/elements 16.0.0-next.4 → 16.0.0-next.5

package/esm2022/src/component-factory-strategy.mjs

@@ -0,0 +1,251 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ApplicationRef, ChangeDetectorRef, ComponentFactoryResolver, Injector, NgZone, SimpleChange } from '@angular/core';
+import { merge, ReplaySubject } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { extractProjectableNodes } from './extract-projectable-nodes';
+import { isFunction, scheduler, strictEquals } from './utils';
+/** Time in milliseconds to wait before destroying the component ref when disconnected. */
+const DESTROY_DELAY = 10;
+/**
+ * Factory that creates new ComponentNgElementStrategy instance. Gets the component factory with the
+ * constructor's injector's factory resolver and passes that factory to each strategy.
+ *
+ * @publicApi
+ */
+export class ComponentNgElementStrategyFactory {
+    constructor(component, injector) {
+        this.componentFactory =
+            injector.get(ComponentFactoryResolver).resolveComponentFactory(component);
+    }
+    create(injector) {
+        return new ComponentNgElementStrategy(this.componentFactory, injector);
+    }
+}
+/**
+ * Creates and destroys a component ref using a component factory and handles change detection
+ * in response to input changes.
+ *
+ * @publicApi
+ */
+export class ComponentNgElementStrategy {
+    constructor(componentFactory, injector) {
+        this.componentFactory = componentFactory;
+        this.injector = injector;
+        // Subject of `NgElementStrategyEvent` observables corresponding to the component's outputs.
+        this.eventEmitters = new ReplaySubject(1);
+        /** Merged stream of the component's output events. */
+        this.events = this.eventEmitters.pipe(switchMap(emitters => merge(...emitters)));
+        /** Reference to the component that was created on connect. */
+        this.componentRef = null;
+        /** Reference to the component view's `ChangeDetectorRef`. */
+        this.viewChangeDetectorRef = null;
+        /**
+         * Changes that have been made to component inputs since the last change detection run.
+         * (NOTE: These are only recorded if the component implements the `OnChanges` interface.)
+         */
+        this.inputChanges = null;
+        /** Whether changes have been made to component inputs since the last change detection run. */
+        this.hasInputChanges = false;
+        /** Whether the created component implements the `OnChanges` interface. */
+        this.implementsOnChanges = false;
+        /** Whether a change detection has been scheduled to run on the component. */
+        this.scheduledChangeDetectionFn = null;
+        /** Callback function that when called will cancel a scheduled destruction on the component. */
+        this.scheduledDestroyFn = null;
+        /** Initial input values that were set before the component was created. */
+        this.initialInputValues = new Map();
+        this.unchangedInputs =
+            new Set(this.componentFactory.inputs.map(({ propName }) => propName));
+        this.ngZone = this.injector.get(NgZone);
+        this.elementZone = (typeof Zone === 'undefined') ? null : this.ngZone.run(() => Zone.current);
+    }
+    /**
+     * Initializes a new component if one has not yet been created and cancels any scheduled
+     * destruction.
+     */
+    connect(element) {
+        this.runInZone(() => {
+            // If the element is marked to be destroyed, cancel the task since the component was
+            // reconnected
+            if (this.scheduledDestroyFn !== null) {
+                this.scheduledDestroyFn();
+                this.scheduledDestroyFn = null;
+                return;
+            }
+            if (this.componentRef === null) {
+                this.initializeComponent(element);
+            }
+        });
+    }
+    /**
+     * Schedules the component to be destroyed after some small delay in case the element is just
+     * being moved across the DOM.
+     */
+    disconnect() {
+        this.runInZone(() => {
+            // Return if there is no componentRef or the component is already scheduled for destruction
+            if (this.componentRef === null || this.scheduledDestroyFn !== null) {
+                return;
+            }
+            // Schedule the component to be destroyed after a small timeout in case it is being
+            // moved elsewhere in the DOM
+            this.scheduledDestroyFn = scheduler.schedule(() => {
+                if (this.componentRef !== null) {
+                    this.componentRef.destroy();
+                    this.componentRef = null;
+                    this.viewChangeDetectorRef = null;
+                }
+            }, DESTROY_DELAY);
+        });
+    }
+    /**
+     * Returns the component property value. If the component has not yet been created, the value is
+     * retrieved from the cached initialization values.
+     */
+    getInputValue(property) {
+        return this.runInZone(() => {
+            if (this.componentRef === null) {
+                return this.initialInputValues.get(property);
+            }
+            return this.componentRef.instance[property];
+        });
+    }
+    /**
+     * Sets the input value for the property. If the component has not yet been created, the value is
+     * cached and set when the component is created.
+     */
+    setInputValue(property, value) {
+        this.runInZone(() => {
+            if (this.componentRef === null) {
+                this.initialInputValues.set(property, value);
+                return;
+            }
+            // Ignore the value if it is strictly equal to the current value, except if it is `undefined`
+            // and this is the first change to the value (because an explicit `undefined` _is_ strictly
+            // equal to not having a value set at all, but we still need to record this as a change).
+            if (strictEquals(value, this.getInputValue(property)) &&
+                !((value === undefined) && this.unchangedInputs.has(property))) {
+                return;
+            }
+            // Record the changed value and update internal state to reflect the fact that this input has
+            // changed.
+            this.recordInputChange(property, value);
+            this.unchangedInputs.delete(property);
+            this.hasInputChanges = true;
+            // Update the component instance and schedule change detection.
+            this.componentRef.instance[property] = value;
+            this.scheduleDetectChanges();
+        });
+    }
+    /**
+     * Creates a new component through the component factory with the provided element host and
+     * sets up its initial inputs, listens for outputs changes, and runs an initial change detection.
+     */
+    initializeComponent(element) {
+        const childInjector = Injector.create({ providers: [], parent: this.injector });
+        const projectableNodes = extractProjectableNodes(element, this.componentFactory.ngContentSelectors);
+        this.componentRef = this.componentFactory.create(childInjector, projectableNodes, element);
+        this.viewChangeDetectorRef = this.componentRef.injector.get(ChangeDetectorRef);
+        this.implementsOnChanges = isFunction(this.componentRef.instance.ngOnChanges);
+        this.initializeInputs();
+        this.initializeOutputs(this.componentRef);
+        this.detectChanges();
+        const applicationRef = this.injector.get(ApplicationRef);
+        applicationRef.attachView(this.componentRef.hostView);
+    }
+    /** Set any stored initial inputs on the component's properties. */
+    initializeInputs() {
+        this.componentFactory.inputs.forEach(({ propName }) => {
+            if (this.initialInputValues.has(propName)) {
+                // Call `setInputValue()` now that the component has been instantiated to update its
+                // properties and fire `ngOnChanges()`.
+                this.setInputValue(propName, this.initialInputValues.get(propName));
+            }
+        });
+        this.initialInputValues.clear();
+    }
+    /** Sets up listeners for the component's outputs so that the events stream emits the events. */
+    initializeOutputs(componentRef) {
+        const eventEmitters = this.componentFactory.outputs.map(({ propName, templateName }) => {
+            const emitter = componentRef.instance[propName];
+            return emitter.pipe(map(value => ({ name: templateName, value })));
+        });
+        this.eventEmitters.next(eventEmitters);
+    }
+    /** Calls ngOnChanges with all the inputs that have changed since the last call. */
+    callNgOnChanges(componentRef) {
+        if (!this.implementsOnChanges || this.inputChanges === null) {
+            return;
+        }
+        // Cache the changes and set inputChanges to null to capture any changes that might occur
+        // during ngOnChanges.
+        const inputChanges = this.inputChanges;
+        this.inputChanges = null;
+        componentRef.instance.ngOnChanges(inputChanges);
+    }
+    /**
+     * Marks the component view for check, if necessary.
+     * (NOTE: This is required when the `ChangeDetectionStrategy` is set to `OnPush`.)
+     */
+    markViewForCheck(viewChangeDetectorRef) {
+        if (this.hasInputChanges) {
+            this.hasInputChanges = false;
+            viewChangeDetectorRef.markForCheck();
+        }
+    }
+    /**
+     * Schedules change detection to run on the component.
+     * Ignores subsequent calls if already scheduled.
+     */
+    scheduleDetectChanges() {
+        if (this.scheduledChangeDetectionFn) {
+            return;
+        }
+        this.scheduledChangeDetectionFn = scheduler.scheduleBeforeRender(() => {
+            this.scheduledChangeDetectionFn = null;
+            this.detectChanges();
+        });
+    }
+    /**
+     * Records input changes so that the component receives SimpleChanges in its onChanges function.
+     */
+    recordInputChange(property, currentValue) {
+        // Do not record the change if the component does not implement `OnChanges`.
+        if (!this.implementsOnChanges) {
+            return;
+        }
+        if (this.inputChanges === null) {
+            this.inputChanges = {};
+        }
+        // If there already is a change, modify the current value to match but leave the values for
+        // `previousValue` and `isFirstChange`.
+        const pendingChange = this.inputChanges[property];
+        if (pendingChange) {
+            pendingChange.currentValue = currentValue;
+            return;
+        }
+        const isFirstChange = this.unchangedInputs.has(property);
+        const previousValue = isFirstChange ? undefined : this.getInputValue(property);
+        this.inputChanges[property] = new SimpleChange(previousValue, currentValue, isFirstChange);
+    }
+    /** Runs change detection on the component. */
+    detectChanges() {
+        if (this.componentRef === null) {
+            return;
+        }
+        this.callNgOnChanges(this.componentRef);
+        this.markViewForCheck(this.viewChangeDetectorRef);
+        this.componentRef.changeDetectorRef.detectChanges();
+    }
+    /** Runs in the angular zone, if present. */
+    runInZone(fn) {
+        return (this.elementZone && Zone.current !== this.elementZone) ? this.ngZone.run(fn) : fn();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"component-factory-strategy.js","sourceRoot":"","sources":["../../../../../../packages/elements/src/component-factory-strategy.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {ApplicationRef, ChangeDetectorRef, ComponentFactory, ComponentFactoryResolver, ComponentRef, EventEmitter, Injector, NgZone, OnChanges, SimpleChange, SimpleChanges, Type} from '@angular/core';\nimport {merge, Observable, ReplaySubject} from 'rxjs';\nimport {map, switchMap} from 'rxjs/operators';\n\nimport {NgElementStrategy, NgElementStrategyEvent, NgElementStrategyFactory} from './element-strategy';\nimport {extractProjectableNodes} from './extract-projectable-nodes';\nimport {isFunction, scheduler, strictEquals} from './utils';\n\n/** Time in milliseconds to wait before destroying the component ref when disconnected. */\nconst DESTROY_DELAY = 10;\n\n/**\n * Factory that creates new ComponentNgElementStrategy instance. Gets the component factory with the\n * constructor's injector's factory resolver and passes that factory to each strategy.\n *\n * @publicApi\n */\nexport class ComponentNgElementStrategyFactory implements NgElementStrategyFactory {\n  componentFactory: ComponentFactory<any>;\n\n  constructor(component: Type<any>, injector: Injector) {\n    this.componentFactory =\n        injector.get(ComponentFactoryResolver).resolveComponentFactory(component);\n  }\n\n  create(injector: Injector) {\n    return new ComponentNgElementStrategy(this.componentFactory, injector);\n  }\n}\n\n/**\n * Creates and destroys a component ref using a component factory and handles change detection\n * in response to input changes.\n *\n * @publicApi\n */\nexport class ComponentNgElementStrategy implements NgElementStrategy {\n  // Subject of `NgElementStrategyEvent` observables corresponding to the component's outputs.\n  private eventEmitters = new ReplaySubject<Observable<NgElementStrategyEvent>[]>(1);\n\n  /** Merged stream of the component's output events. */\n  readonly events = this.eventEmitters.pipe(switchMap(emitters => merge(...emitters)));\n\n  /** Reference to the component that was created on connect. */\n  private componentRef: ComponentRef<any>|null = null;\n\n  /** Reference to the component view's `ChangeDetectorRef`. */\n  private viewChangeDetectorRef: ChangeDetectorRef|null = null;\n\n  /**\n   * Changes that have been made to component inputs since the last change detection run.\n   * (NOTE: These are only recorded if the component implements the `OnChanges` interface.)\n   */\n  private inputChanges: SimpleChanges|null = null;\n\n  /** Whether changes have been made to component inputs since the last change detection run. */\n  private hasInputChanges = false;\n\n  /** Whether the created component implements the `OnChanges` interface. */\n  private implementsOnChanges = false;\n\n  /** Whether a change detection has been scheduled to run on the component. */\n  private scheduledChangeDetectionFn: (() => void)|null = null;\n\n  /** Callback function that when called will cancel a scheduled destruction on the component. */\n  private scheduledDestroyFn: (() => void)|null = null;\n\n  /** Initial input values that were set before the component was created. */\n  private readonly initialInputValues = new Map<string, any>();\n\n  /**\n   * Set of component inputs that have not yet changed, i.e. for which `recordInputChange()` has not\n   * fired.\n   * (This helps detect the first change of an input, even if it is explicitly set to `undefined`.)\n   */\n  private readonly unchangedInputs: Set<string>;\n\n  /** Service for setting zone context. */\n  private readonly ngZone: NgZone;\n\n  /** The zone the element was created in or `null` if Zone.js is not loaded. */\n  private readonly elementZone: Zone|null;\n\n\n  constructor(private componentFactory: ComponentFactory<any>, private injector: Injector) {\n    this.unchangedInputs =\n        new Set<string>(this.componentFactory.inputs.map(({propName}) => propName));\n    this.ngZone = this.injector.get<NgZone>(NgZone);\n    this.elementZone = (typeof Zone === 'undefined') ? null : this.ngZone.run(() => Zone.current);\n  }\n\n  /**\n   * Initializes a new component if one has not yet been created and cancels any scheduled\n   * destruction.\n   */\n  connect(element: HTMLElement) {\n    this.runInZone(() => {\n      // If the element is marked to be destroyed, cancel the task since the component was\n      // reconnected\n      if (this.scheduledDestroyFn !== null) {\n        this.scheduledDestroyFn();\n        this.scheduledDestroyFn = null;\n        return;\n      }\n\n      if (this.componentRef === null) {\n        this.initializeComponent(element);\n      }\n    });\n  }\n\n  /**\n   * Schedules the component to be destroyed after some small delay in case the element is just\n   * being moved across the DOM.\n   */\n  disconnect() {\n    this.runInZone(() => {\n      // Return if there is no componentRef or the component is already scheduled for destruction\n      if (this.componentRef === null || this.scheduledDestroyFn !== null) {\n        return;\n      }\n\n      // Schedule the component to be destroyed after a small timeout in case it is being\n      // moved elsewhere in the DOM\n      this.scheduledDestroyFn = scheduler.schedule(() => {\n        if (this.componentRef !== null) {\n          this.componentRef.destroy();\n          this.componentRef = null;\n          this.viewChangeDetectorRef = null;\n        }\n      }, DESTROY_DELAY);\n    });\n  }\n\n  /**\n   * Returns the component property value. If the component has not yet been created, the value is\n   * retrieved from the cached initialization values.\n   */\n  getInputValue(property: string): any {\n    return this.runInZone(() => {\n      if (this.componentRef === null) {\n        return this.initialInputValues.get(property);\n      }\n\n      return this.componentRef.instance[property];\n    });\n  }\n\n  /**\n   * Sets the input value for the property. If the component has not yet been created, the value is\n   * cached and set when the component is created.\n   */\n  setInputValue(property: string, value: any): void {\n    this.runInZone(() => {\n      if (this.componentRef === null) {\n        this.initialInputValues.set(property, value);\n        return;\n      }\n\n      // Ignore the value if it is strictly equal to the current value, except if it is `undefined`\n      // and this is the first change to the value (because an explicit `undefined` _is_ strictly\n      // equal to not having a value set at all, but we still need to record this as a change).\n      if (strictEquals(value, this.getInputValue(property)) &&\n          !((value === undefined) && this.unchangedInputs.has(property))) {\n        return;\n      }\n\n      // Record the changed value and update internal state to reflect the fact that this input has\n      // changed.\n      this.recordInputChange(property, value);\n      this.unchangedInputs.delete(property);\n      this.hasInputChanges = true;\n\n      // Update the component instance and schedule change detection.\n      this.componentRef.instance[property] = value;\n      this.scheduleDetectChanges();\n    });\n  }\n\n  /**\n   * Creates a new component through the component factory with the provided element host and\n   * sets up its initial inputs, listens for outputs changes, and runs an initial change detection.\n   */\n  protected initializeComponent(element: HTMLElement) {\n    const childInjector = Injector.create({providers: [], parent: this.injector});\n    const projectableNodes =\n        extractProjectableNodes(element, this.componentFactory.ngContentSelectors);\n    this.componentRef = this.componentFactory.create(childInjector, projectableNodes, element);\n    this.viewChangeDetectorRef = this.componentRef.injector.get(ChangeDetectorRef);\n\n    this.implementsOnChanges = isFunction((this.componentRef.instance as OnChanges).ngOnChanges);\n\n    this.initializeInputs();\n    this.initializeOutputs(this.componentRef);\n\n    this.detectChanges();\n\n    const applicationRef = this.injector.get<ApplicationRef>(ApplicationRef);\n    applicationRef.attachView(this.componentRef.hostView);\n  }\n\n  /** Set any stored initial inputs on the component's properties. */\n  protected initializeInputs(): void {\n    this.componentFactory.inputs.forEach(({propName}) => {\n      if (this.initialInputValues.has(propName)) {\n        // Call `setInputValue()` now that the component has been instantiated to update its\n        // properties and fire `ngOnChanges()`.\n        this.setInputValue(propName, this.initialInputValues.get(propName));\n      }\n    });\n\n    this.initialInputValues.clear();\n  }\n\n  /** Sets up listeners for the component's outputs so that the events stream emits the events. */\n  protected initializeOutputs(componentRef: ComponentRef<any>): void {\n    const eventEmitters: Observable<NgElementStrategyEvent>[] =\n        this.componentFactory.outputs.map(({propName, templateName}) => {\n          const emitter: EventEmitter<any> = componentRef.instance[propName];\n          return emitter.pipe(map(value => ({name: templateName, value})));\n        });\n\n    this.eventEmitters.next(eventEmitters);\n  }\n\n  /** Calls ngOnChanges with all the inputs that have changed since the last call. */\n  protected callNgOnChanges(componentRef: ComponentRef<any>): void {\n    if (!this.implementsOnChanges || this.inputChanges === null) {\n      return;\n    }\n\n    // Cache the changes and set inputChanges to null to capture any changes that might occur\n    // during ngOnChanges.\n    const inputChanges = this.inputChanges;\n    this.inputChanges = null;\n    (componentRef.instance as OnChanges).ngOnChanges(inputChanges);\n  }\n\n  /**\n   * Marks the component view for check, if necessary.\n   * (NOTE: This is required when the `ChangeDetectionStrategy` is set to `OnPush`.)\n   */\n  protected markViewForCheck(viewChangeDetectorRef: ChangeDetectorRef): void {\n    if (this.hasInputChanges) {\n      this.hasInputChanges = false;\n      viewChangeDetectorRef.markForCheck();\n    }\n  }\n\n  /**\n   * Schedules change detection to run on the component.\n   * Ignores subsequent calls if already scheduled.\n   */\n  protected scheduleDetectChanges(): void {\n    if (this.scheduledChangeDetectionFn) {\n      return;\n    }\n\n    this.scheduledChangeDetectionFn = scheduler.scheduleBeforeRender(() => {\n      this.scheduledChangeDetectionFn = null;\n      this.detectChanges();\n    });\n  }\n\n  /**\n   * Records input changes so that the component receives SimpleChanges in its onChanges function.\n   */\n  protected recordInputChange(property: string, currentValue: any): void {\n    // Do not record the change if the component does not implement `OnChanges`.\n    if (!this.implementsOnChanges) {\n      return;\n    }\n\n    if (this.inputChanges === null) {\n      this.inputChanges = {};\n    }\n\n    // If there already is a change, modify the current value to match but leave the values for\n    // `previousValue` and `isFirstChange`.\n    const pendingChange = this.inputChanges[property];\n    if (pendingChange) {\n      pendingChange.currentValue = currentValue;\n      return;\n    }\n\n    const isFirstChange = this.unchangedInputs.has(property);\n    const previousValue = isFirstChange ? undefined : this.getInputValue(property);\n    this.inputChanges[property] = new SimpleChange(previousValue, currentValue, isFirstChange);\n  }\n\n  /** Runs change detection on the component. */\n  protected detectChanges(): void {\n    if (this.componentRef === null) {\n      return;\n    }\n\n    this.callNgOnChanges(this.componentRef);\n    this.markViewForCheck(this.viewChangeDetectorRef!);\n    this.componentRef.changeDetectorRef.detectChanges();\n  }\n\n  /** Runs in the angular zone, if present. */\n  private runInZone(fn: () => unknown) {\n    return (this.elementZone && Zone.current !== this.elementZone) ? this.ngZone.run(fn) : fn();\n  }\n}\n"]}

package/esm2022/src/create-custom-element.mjs

@@ -0,0 +1,143 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * Use of this source code is governed by an MIT-style license that can be
+ * found in the LICENSE file at https://angular.io/license
+ */
+import { ComponentNgElementStrategyFactory } from './component-factory-strategy';
+import { getComponentInputs, getDefaultAttributeToPropertyInputs } from './utils';
+/**
+ * Implements the functionality needed for a custom element.
+ *
+ * @publicApi
+ */
+export class NgElement extends HTMLElement {
+    constructor() {
+        super(...arguments);
+        /**
+         * A subscription to change, connect, and disconnect events in the custom element.
+         */
+        this.ngElementEventsSubscription = null;
+    }
+}
+/**
+ *  @description Creates a custom element class based on an Angular component.
+ *
+ * Builds a class that encapsulates the functionality of the provided component and
+ * uses the configuration information to provide more context to the class.
+ * Takes the component factory's inputs and outputs to convert them to the proper
+ * custom element API and add hooks to input changes.
+ *
+ * The configuration's injector is the initial injector set on the class,
+ * and used by default for each created instance.This behavior can be overridden with the
+ * static property to affect all newly created instances, or as a constructor argument for
+ * one-off creations.
+ *
+ * @see [Angular Elements Overview](guide/elements "Turning Angular components into custom elements")
+ *
+ * @param component The component to transform.
+ * @param config A configuration that provides initialization information to the created class.
+ * @returns The custom-element construction class, which can be registered with
+ * a browser's `CustomElementRegistry`.
+ *
+ * @publicApi
+ */
+export function createCustomElement(component, config) {
+    const inputs = getComponentInputs(component, config.injector);
+    const strategyFactory = config.strategyFactory || new ComponentNgElementStrategyFactory(component, config.injector);
+    const attributeToPropertyInputs = getDefaultAttributeToPropertyInputs(inputs);
+    class NgElementImpl extends NgElement {
+        // Work around a bug in closure typed optimizations(b/79557487) where it is not honoring static
+        // field externs. So using quoted access to explicitly prevent renaming.
+        static { this['observedAttributes'] = Object.keys(attributeToPropertyInputs); }
+        get ngElementStrategy() {
+            // NOTE:
+            // Some polyfills (e.g. `document-register-element`) do not call the constructor, therefore
+            // it is not safe to set `ngElementStrategy` in the constructor and assume it will be
+            // available inside the methods.
+            //
+            // TODO(andrewseguin): Add e2e tests that cover cases where the constructor isn't called. For
+            // now this is tested using a Google internal test suite.
+            if (!this._ngElementStrategy) {
+                const strategy = this._ngElementStrategy =
+                    strategyFactory.create(this.injector || config.injector);
+                // Re-apply pre-existing input values (set as properties on the element) through the
+                // strategy.
+                inputs.forEach(({ propName }) => {
+                    if (!this.hasOwnProperty(propName)) {
+                        // No pre-existing value for `propName`.
+                        return;
+                    }
+                    // Delete the property from the instance and re-apply it through the strategy.
+                    const value = this[propName];
+                    delete this[propName];
+                    strategy.setInputValue(propName, value);
+                });
+            }
+            return this._ngElementStrategy;
+        }
+        constructor(injector) {
+            super();
+            this.injector = injector;
+        }
+        attributeChangedCallback(attrName, oldValue, newValue, namespace) {
+            const propName = attributeToPropertyInputs[attrName];
+            this.ngElementStrategy.setInputValue(propName, newValue);
+        }
+        connectedCallback() {
+            // For historical reasons, some strategies may not have initialized the `events` property
+            // until after `connect()` is run. Subscribe to `events` if it is available before running
+            // `connect()` (in order to capture events emitted during initialization), otherwise subscribe
+            // afterwards.
+            //
+            // TODO: Consider deprecating/removing the post-connect subscription in a future major version
+            //       (e.g. v11).
+            let subscribedToEvents = false;
+            if (this.ngElementStrategy.events) {
+                // `events` are already available: Subscribe to it asap.
+                this.subscribeToEvents();
+                subscribedToEvents = true;
+            }
+            this.ngElementStrategy.connect(this);
+            if (!subscribedToEvents) {
+                // `events` were not initialized before running `connect()`: Subscribe to them now.
+                // The events emitted during the component initialization have been missed, but at least
+                // future events will be captured.
+                this.subscribeToEvents();
+            }
+        }
+        disconnectedCallback() {
+            // Not using `this.ngElementStrategy` to avoid unnecessarily creating the `NgElementStrategy`.
+            if (this._ngElementStrategy) {
+                this._ngElementStrategy.disconnect();
+            }
+            if (this.ngElementEventsSubscription) {
+                this.ngElementEventsSubscription.unsubscribe();
+                this.ngElementEventsSubscription = null;
+            }
+        }
+        subscribeToEvents() {
+            // Listen for events from the strategy and dispatch them as custom events.
+            this.ngElementEventsSubscription = this.ngElementStrategy.events.subscribe(e => {
+                const customEvent = new CustomEvent(e.name, { detail: e.value });
+                this.dispatchEvent(customEvent);
+            });
+        }
+    }
+    // Add getters and setters to the prototype for each property input.
+    inputs.forEach(({ propName }) => {
+        Object.defineProperty(NgElementImpl.prototype, propName, {
+            get() {
+                return this.ngElementStrategy.getInputValue(propName);
+            },
+            set(newValue) {
+                this.ngElementStrategy.setInputValue(propName, newValue);
+            },
+            configurable: true,
+            enumerable: true,
+        });
+    });
+    return NgElementImpl;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-custom-element.js","sourceRoot":"","sources":["../../../../../../packages/elements/src/create-custom-element.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Injector, Type} from '@angular/core';\nimport {Subscription} from 'rxjs';\n\nimport {ComponentNgElementStrategyFactory} from './component-factory-strategy';\nimport {NgElementStrategy, NgElementStrategyFactory} from './element-strategy';\nimport {getComponentInputs, getDefaultAttributeToPropertyInputs} from './utils';\n\n/**\n * Prototype for a class constructor based on an Angular component\n * that can be used for custom element registration. Implemented and returned\n * by the {@link createCustomElement createCustomElement() function}.\n *\n * @see [Angular Elements Overview](guide/elements \"Turning Angular components into custom elements\")\n *\n * @publicApi\n */\nexport interface NgElementConstructor<P> {\n  /**\n   * An array of observed attribute names for the custom element,\n   * derived by transforming input property names from the source component.\n   */\n  readonly observedAttributes: string[];\n\n  /**\n   * Initializes a constructor instance.\n   * @param injector If provided, overrides the configured injector.\n   */\n  new(injector?: Injector): NgElement&WithProperties<P>;\n}\n\n/**\n * Implements the functionality needed for a custom element.\n *\n * @publicApi\n */\nexport abstract class NgElement extends HTMLElement {\n  /**\n   * The strategy that controls how a component is transformed in a custom element.\n   */\n  protected abstract ngElementStrategy: NgElementStrategy;\n  /**\n   * A subscription to change, connect, and disconnect events in the custom element.\n   */\n  protected ngElementEventsSubscription: Subscription|null = null;\n\n  /**\n   * Prototype for a handler that responds to a change in an observed attribute.\n   * @param attrName The name of the attribute that has changed.\n   * @param oldValue The previous value of the attribute.\n   * @param newValue The new value of the attribute.\n   * @param namespace The namespace in which the attribute is defined.\n   * @returns Nothing.\n   */\n  abstract attributeChangedCallback(\n      attrName: string, oldValue: string|null, newValue: string, namespace?: string): void;\n  /**\n   * Prototype for a handler that responds to the insertion of the custom element in the DOM.\n   * @returns Nothing.\n   */\n  abstract connectedCallback(): void;\n  /**\n   * Prototype for a handler that responds to the deletion of the custom element from the DOM.\n   * @returns Nothing.\n   */\n  abstract disconnectedCallback(): void;\n}\n\n/**\n * Additional type information that can be added to the NgElement class,\n * for properties that are added based\n * on the inputs and methods of the underlying component.\n *\n * @publicApi\n */\nexport type WithProperties<P> = {\n  [property in keyof P]: P[property]\n};\n\n/**\n * A configuration that initializes an NgElementConstructor with the\n * dependencies and strategy it needs to transform a component into\n * a custom element class.\n *\n * @publicApi\n */\nexport interface NgElementConfig {\n  /**\n   * The injector to use for retrieving the component's factory.\n   */\n  injector: Injector;\n  /**\n   * An optional custom strategy factory to use instead of the default.\n   * The strategy controls how the transformation is performed.\n   */\n  strategyFactory?: NgElementStrategyFactory;\n}\n\n/**\n *  @description Creates a custom element class based on an Angular component.\n *\n * Builds a class that encapsulates the functionality of the provided component and\n * uses the configuration information to provide more context to the class.\n * Takes the component factory's inputs and outputs to convert them to the proper\n * custom element API and add hooks to input changes.\n *\n * The configuration's injector is the initial injector set on the class,\n * and used by default for each created instance.This behavior can be overridden with the\n * static property to affect all newly created instances, or as a constructor argument for\n * one-off creations.\n *\n * @see [Angular Elements Overview](guide/elements \"Turning Angular components into custom elements\")\n *\n * @param component The component to transform.\n * @param config A configuration that provides initialization information to the created class.\n * @returns The custom-element construction class, which can be registered with\n * a browser's `CustomElementRegistry`.\n *\n * @publicApi\n */\nexport function createCustomElement<P>(\n    component: Type<any>, config: NgElementConfig): NgElementConstructor<P> {\n  const inputs = getComponentInputs(component, config.injector);\n\n  const strategyFactory =\n      config.strategyFactory || new ComponentNgElementStrategyFactory(component, config.injector);\n\n  const attributeToPropertyInputs = getDefaultAttributeToPropertyInputs(inputs);\n\n  class NgElementImpl extends NgElement {\n    // Work around a bug in closure typed optimizations(b/79557487) where it is not honoring static\n    // field externs. So using quoted access to explicitly prevent renaming.\n    static readonly['observedAttributes'] = Object.keys(attributeToPropertyInputs);\n\n    protected override get ngElementStrategy(): NgElementStrategy {\n      // NOTE:\n      // Some polyfills (e.g. `document-register-element`) do not call the constructor, therefore\n      // it is not safe to set `ngElementStrategy` in the constructor and assume it will be\n      // available inside the methods.\n      //\n      // TODO(andrewseguin): Add e2e tests that cover cases where the constructor isn't called. For\n      // now this is tested using a Google internal test suite.\n      if (!this._ngElementStrategy) {\n        const strategy = this._ngElementStrategy =\n            strategyFactory.create(this.injector || config.injector);\n\n        // Re-apply pre-existing input values (set as properties on the element) through the\n        // strategy.\n        inputs.forEach(({propName}) => {\n          if (!this.hasOwnProperty(propName)) {\n            // No pre-existing value for `propName`.\n            return;\n          }\n\n          // Delete the property from the instance and re-apply it through the strategy.\n          const value = (this as any)[propName];\n          delete (this as any)[propName];\n          strategy.setInputValue(propName, value);\n        });\n      }\n\n      return this._ngElementStrategy!;\n    }\n\n    private _ngElementStrategy?: NgElementStrategy;\n\n    constructor(private readonly injector?: Injector) {\n      super();\n    }\n\n    override attributeChangedCallback(\n        attrName: string, oldValue: string|null, newValue: string, namespace?: string): void {\n      const propName = attributeToPropertyInputs[attrName]!;\n      this.ngElementStrategy.setInputValue(propName, newValue);\n    }\n\n    override connectedCallback(): void {\n      // For historical reasons, some strategies may not have initialized the `events` property\n      // until after `connect()` is run. Subscribe to `events` if it is available before running\n      // `connect()` (in order to capture events emitted during initialization), otherwise subscribe\n      // afterwards.\n      //\n      // TODO: Consider deprecating/removing the post-connect subscription in a future major version\n      //       (e.g. v11).\n\n      let subscribedToEvents = false;\n\n      if (this.ngElementStrategy.events) {\n        // `events` are already available: Subscribe to it asap.\n        this.subscribeToEvents();\n        subscribedToEvents = true;\n      }\n\n      this.ngElementStrategy.connect(this);\n\n      if (!subscribedToEvents) {\n        // `events` were not initialized before running `connect()`: Subscribe to them now.\n        // The events emitted during the component initialization have been missed, but at least\n        // future events will be captured.\n        this.subscribeToEvents();\n      }\n    }\n\n    override disconnectedCallback(): void {\n      // Not using `this.ngElementStrategy` to avoid unnecessarily creating the `NgElementStrategy`.\n      if (this._ngElementStrategy) {\n        this._ngElementStrategy.disconnect();\n      }\n\n      if (this.ngElementEventsSubscription) {\n        this.ngElementEventsSubscription.unsubscribe();\n        this.ngElementEventsSubscription = null;\n      }\n    }\n\n    private subscribeToEvents(): void {\n      // Listen for events from the strategy and dispatch them as custom events.\n      this.ngElementEventsSubscription = this.ngElementStrategy.events.subscribe(e => {\n        const customEvent = new CustomEvent(e.name, {detail: e.value});\n        this.dispatchEvent(customEvent);\n      });\n    }\n  }\n\n  // Add getters and setters to the prototype for each property input.\n  inputs.forEach(({propName}) => {\n    Object.defineProperty(NgElementImpl.prototype, propName, {\n      get(): any {\n        return this.ngElementStrategy.getInputValue(propName);\n      },\n      set(newValue: any): void {\n        this.ngElementStrategy.setInputValue(propName, newValue);\n      },\n      configurable: true,\n      enumerable: true,\n    });\n  });\n\n  return (NgElementImpl as any) as NgElementConstructor<P>;\n}\n"]}

package/{esm2020 → esm2022}/src/version.mjs

@@ -9,5 +9,5 @@ import { Version } from '@angular/core';
 /**
  * @publicApi
  */
-export const VERSION = new Version('16.0.0-next.4');
+export const VERSION = new Version('16.0.0-next.5');
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3BhY2thZ2VzL2VsZW1lbnRzL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILE9BQU8sRUFBQyxPQUFPLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFFdEM7O0dBRUc7QUFDSCxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsSUFBSSxPQUFPLENBQUMsbUJBQW1CLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCBHb29nbGUgTExDIEFsbCBSaWdodHMgUmVzZXJ2ZWQuXG4gKlxuICogVXNlIG9mIHRoaXMgc291cmNlIGNvZGUgaXMgZ292ZXJuZWQgYnkgYW4gTUlULXN0eWxlIGxpY2Vuc2UgdGhhdCBjYW4gYmVcbiAqIGZvdW5kIGluIHRoZSBMSUNFTlNFIGZpbGUgYXQgaHR0cHM6Ly9hbmd1bGFyLmlvL2xpY2Vuc2VcbiAqL1xuXG5pbXBvcnQge1ZlcnNpb259IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG4vKipcbiAqIEBwdWJsaWNBcGlcbiAqL1xuZXhwb3J0IGNvbnN0IFZFUlNJT04gPSBuZXcgVmVyc2lvbignMC4wLjAtUExBQ0VIT0xERVInKTtcbiJdfQ==

package/{fesm2015 → fesm2022}/elements.mjs

@@ -1,5 +1,5 @@
 /**
- * @license Angular v16.0.0-next.4
+ * @license Angular v16.0.0-next.5
  * (c) 2010-2022 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -189,15 +189,9 @@ class ComponentNgElementStrategy {
         this.scheduledDestroyFn = null;
         /** Initial input values that were set before the component was created. */
         this.initialInputValues = new Map();
-        /**
-         * Set of component inputs that have not yet changed, i.e. for which `recordInputChange()` has not
-         * fired.
-         * (This helps detect the first change of an input, even if it is explicitly set to `undefined`.)
-         */
-        this.unchangedInputs = new Set(this.componentFactory.inputs.map(({ propName }) => propName));
-        /** Service for setting zone context. */
+        this.unchangedInputs =
+            new Set(this.componentFactory.inputs.map(({ propName }) => propName));
         this.ngZone = this.injector.get(NgZone);
-        /** The zone the element was created in or `null` if Zone.js is not loaded. */
         this.elementZone = (typeof Zone === 'undefined') ? null : this.ngZone.run(() => Zone.current);
     }
     /**
@@ -425,6 +419,9 @@ function createCustomElement(component, config) {
     const strategyFactory = config.strategyFactory || new ComponentNgElementStrategyFactory(component, config.injector);
     const attributeToPropertyInputs = getDefaultAttributeToPropertyInputs(inputs);
     class NgElementImpl extends NgElement {
+        // Work around a bug in closure typed optimizations(b/79557487) where it is not honoring static
+        // field externs. So using quoted access to explicitly prevent renaming.
+        static { this['observedAttributes'] = Object.keys(attributeToPropertyInputs); }
         get ngElementStrategy() {
             // NOTE:
             // Some polyfills (e.g. `document-register-element`) do not call the constructor, therefore
@@ -499,9 +496,6 @@ function createCustomElement(component, config) {
             });
         }
     }
-    // Work around a bug in closure typed optimizations(b/79557487) where it is not honoring static
-    // field externs. So using quoted access to explicitly prevent renaming.
-    NgElementImpl['observedAttributes'] = Object.keys(attributeToPropertyInputs);
     // Add getters and setters to the prototype for each property input.
     inputs.forEach(({ propName }) => {
         Object.defineProperty(NgElementImpl.prototype, propName, {
@@ -521,7 +515,7 @@ function createCustomElement(component, config) {
 /**
  * @publicApi
  */
-const VERSION = new Version('16.0.0-next.4');
+const VERSION = new Version('16.0.0-next.5');
 
 /**
  * @module