• Home
• org.mvnpm.at.angular
• elements
• 18.2.3
• source code
• component-factory-strategy.mjs

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

package.esm2022.src.component-factory-strategy.mjs Maven / Gradle / Ivy

/**
 * @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.
 */
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.
 */
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, transform) {
        this.runInZone(() => {
            if (transform) {
                value = transform.call(this.componentRef?.instance, value);
            }
            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, transform }) => {
            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), transform);
            }
        });
        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 {\n  ApplicationRef,\n  ChangeDetectorRef,\n  ComponentFactory,\n  ComponentFactoryResolver,\n  ComponentRef,\n  EventEmitter,\n  Injector,\n  NgZone,\n  OnChanges,\n  SimpleChange,\n  SimpleChanges,\n  Type,\n} from '@angular/core';\nimport {merge, Observable, ReplaySubject} from 'rxjs';\nimport {map, switchMap} from 'rxjs/operators';\n\nimport {\n  NgElementStrategy,\n  NgElementStrategyEvent,\n  NgElementStrategyFactory,\n} 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 */\nexport class ComponentNgElementStrategyFactory implements NgElementStrategyFactory {\n  componentFactory: ComponentFactory<any>;\n\n  constructor(component: Type<any>, injector: Injector) {\n    this.componentFactory = injector\n      .get(ComponentFactoryResolver)\n      .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 */\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  constructor(\n    private componentFactory: ComponentFactory<any>,\n    private injector: Injector,\n  ) {\n    this.unchangedInputs = new Set<string>(\n      this.componentFactory.inputs.map(({propName}) => propName),\n    );\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, transform?: (value: any) => any): void {\n    this.runInZone(() => {\n      if (transform) {\n        value = transform.call(this.componentRef?.instance, value);\n      }\n\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 (\n        strictEquals(value, this.getInputValue(property)) &&\n        !(value === undefined && this.unchangedInputs.has(property))\n      ) {\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 = extractProjectableNodes(\n      element,\n      this.componentFactory.ngContentSelectors,\n    );\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, transform}) => {\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), transform);\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>[] = this.componentFactory.outputs.map(\n      ({propName, templateName}) => {\n        const emitter: EventEmitter<any> = componentRef.instance[propName];\n        return emitter.pipe(map((value) => ({name: templateName, value})));\n      },\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"]}