ngx-dynamic-hooks
Version:
Automatically insert live Angular components into a dynamic string of content (based on their selector or any pattern of your choice) and render the result in the DOM.
154 lines • 20.8 kB
JavaScript
import { NgZone, createEnvironmentInjector } from '@angular/core';
import { createApplication } from '@angular/platform-browser';
import { firstValueFrom } from 'rxjs';
import { DynamicHooksService } from './services/dynamicHooksService';
// Global state
// ----------
let sharedInjector = null;
let scopes = [];
let allParseResults = [];
const createInjector = async (providers = [], parent) => {
// If no parent, create new root injector, so passed providers will also be actual root providers
return parent ? createEnvironmentInjector(providers, parent) : (await createApplication({ providers })).injector;
};
/**
* Destroys all scopes and components created by standalone mode
*/
export const destroyAll = () => {
// Destroy all scopes
for (const scope of scopes) {
scope.destroy();
}
// Then all remaining independent parseResults
for (const parseResult of allParseResults) {
parseResult.destroy();
}
sharedInjector = null;
scopes = [];
allParseResults = [];
};
// Providers scope
// ----------
/**
* Creates an isolated scope with its own providers that the dynamically-created components will then have access to.
*
* @param providers - A list of providers
* @param parentScope - An optional parent scope created previously. Makes the parent providers also accessible to this scope.
*/
export const createProviders = (providers = [], parentScope) => {
return new ProvidersScope(providers, parentScope);
};
/**
* A scope with an internal list of providers. All dynamic components created by its `parse` method will have access to them.
*/
export class ProvidersScope {
get injector() {
return this._injector;
}
;
get parseResults() {
return this._parseResults;
}
;
get isDestroyed() {
return this._isDestroyed;
}
;
constructor(providers = [], parentScope) {
this.providers = providers;
this.parentScope = parentScope;
this._injector = null;
this._parseResults = [];
this._isDestroyed = false;
scopes.push(this);
}
/**
* Parses content and loads components for all found hooks in standalone mode
*
* @param content - The content to parse
* @param parsers - The parsers to use
* @param context - An optional context object
* @param options - An optional list of options
* @param targetElement - An optional HTML element to use as the container for the loaded content.
* @param targetHookIndex - An optional object to fill with the programmatic hook data. If none is provided, one is created and returned for you.
* @param environmentInjector - An optional environmentInjector to use for the dynamically-loaded components. If none is provided, the default environmentInjector is used.
*/
async parse(content, parsers, context = null, options = null, targetElement = null, targetHookIndex = {}, environmentInjector = null) {
this.checkIfDestroyed();
return parse(content, parsers, context, options, targetElement, targetHookIndex, environmentInjector || await this.resolveInjector())
.then(parseResult => {
this.parseResults.push(parseResult);
return parseResult;
});
}
/**
* Returns the injector for this scope
*/
async resolveInjector() {
this.checkIfDestroyed();
if (!this.injector) {
const parentInjector = this.parentScope ? await this.parentScope.resolveInjector() : undefined;
this._injector = await createInjector(this.providers, parentInjector);
}
return this.injector;
}
/**
* Destroys this scope and all of its created components
*/
destroy() {
this.checkIfDestroyed();
for (const parseResult of this.parseResults) {
parseResult.destroy();
allParseResults = allParseResults.filter(entry => entry !== parseResult);
}
if (this.injector) {
this.injector.destroy();
}
scopes = scopes.filter(scope => scope !== this);
this._isDestroyed = true;
}
checkIfDestroyed() {
if (this.isDestroyed) {
throw new Error('This scope has already been destroyed. It or its methods cannot be used any longer.');
}
}
}
// parse
// ----------
/**
* Parses content and loads components for all found hooks in standalone mode
*
* @param content - The content to parse
* @param parsers - The parsers to use
* @param context - An optional context object
* @param options - An optional list of options
* @param targetElement - An optional HTML element to use as the container for the loaded content.
* @param targetHookIndex - An optional object to fill with the programmatic hook data. If none is provided, one is created and returned for you.
* @param environmentInjector - An optional environmentInjector to use for the dynamically-loaded components. If none is provided, the default environmentInjector is used.
*/
export const parse = async (content, parsers, context = null, options = null, targetElement = null, targetHookIndex = {}, environmentInjector = null) => {
// Reuse the same global injector for all independent parse calls
if (!environmentInjector) {
if (!sharedInjector) {
sharedInjector = await createInjector();
}
environmentInjector = sharedInjector;
}
// In standalone mode, emit HTML events from outputs by default
if (!options) {
options = {};
}
if (!options.hasOwnProperty('triggerDOMEvents')) {
options.triggerDOMEvents = true;
}
const dynHooksService = environmentInjector.get(DynamicHooksService);
// Needs to be run inside NgZone manually
return environmentInjector.get(NgZone).run(() => {
return firstValueFrom(dynHooksService
.parse(content, parsers, context, options, null, null, targetElement, targetHookIndex, environmentInjector, null)).then(parseResult => {
allParseResults.push(parseResult);
return parseResult;
});
});
};
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"standalone.js","sourceRoot":"","sources":["../../../../projects/ngx-dynamic-hooks/src/lib/standalone.ts"],"names":[],"mappings":"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","sourcesContent":["import { EnvironmentInjector, EnvironmentProviders, NgZone, Provider, createEnvironmentInjector } from '@angular/core';\nimport { createApplication } from '@angular/platform-browser';\nimport { firstValueFrom } from 'rxjs';\n\nimport { HookParserEntry } from './services/settings/parserEntry';\nimport { ParseOptions } from './services/settings/options';\nimport { HookIndex, ParseResult } from './interfacesPublic';\nimport { DynamicHooksService } from './services/dynamicHooksService';\n\n// Global state\n// ----------\n\nlet sharedInjector: EnvironmentInjector|null = null;\nlet scopes: ProvidersScope[] = [];\nlet allParseResults: ParseResult[] = [];\n\nconst createInjector = async (providers: (Provider | EnvironmentProviders)[] = [], parent?: EnvironmentInjector) => {\n  // If no parent, create new root injector, so passed providers will also be actual root providers\n  return parent ? createEnvironmentInjector(providers, parent) : (await createApplication({providers})).injector;\n}\n\n/**\n * Destroys all scopes and components created by standalone mode\n */\nexport const destroyAll = () => {\n  // Destroy all scopes\n  for (const scope of scopes) {\n    scope.destroy();\n  }\n\n  // Then all remaining independent parseResults\n  for (const parseResult of allParseResults) {\n    parseResult.destroy();\n  }\n\n  sharedInjector = null;\n  scopes = [];\n  allParseResults = [];\n}\n\n// Providers scope\n// ----------\n\n/**\n * Creates an isolated scope with its own providers that the dynamically-created components will then have access to.\n * \n * @param providers - A list of providers\n * @param parentScope - An optional parent scope created previously. Makes the parent providers also accessible to this scope.\n */\nexport const createProviders = (providers: (Provider | EnvironmentProviders)[] = [], parentScope?: ProvidersScope): ProvidersScope => {\n  return new ProvidersScope(providers, parentScope);\n}\n\n/**\n * A scope with an internal list of providers. All dynamic components created by its `parse` method will have access to them.\n */\nexport class ProvidersScope {\n  private _injector: EnvironmentInjector|null = null;\n  public get injector(): EnvironmentInjector|null { \n    return this._injector;\n  };\n  private _parseResults: ParseResult[] = [];\n  public get parseResults(): ParseResult[] { \n    return this._parseResults;\n  };\n  private _isDestroyed: boolean = false;\n  get isDestroyed(): boolean {\n    return this._isDestroyed;\n  };\n\n  constructor(private providers: (Provider | EnvironmentProviders)[] = [], private parentScope?: ProvidersScope) {\n    scopes.push(this);\n  }\n\n  /**\n  * Parses content and loads components for all found hooks in standalone mode\n  * \n  * @param content - The content to parse\n  * @param parsers - The parsers to use\n  * @param context - An optional context object\n  * @param options - An optional list of options\n  * @param targetElement - An optional HTML element to use as the container for the loaded content.\n  * @param targetHookIndex - An optional object to fill with the programmatic hook data. If none is provided, one is created and returned for you.\n  * @param environmentInjector - An optional environmentInjector to use for the dynamically-loaded components. If none is provided, the default environmentInjector is used.\n  */\n  public async parse(\n    content: any,\n    parsers: HookParserEntry[],\n    context: any = null,  \n    options: ParseOptions|null = null,\n    targetElement: HTMLElement|null = null,\n    targetHookIndex: HookIndex = {},\n    environmentInjector: EnvironmentInjector|null = null\n  ): Promise<ParseResult> {\n    this.checkIfDestroyed();\n\n    return parse(content, parsers, context, options,  targetElement, targetHookIndex, environmentInjector || await this.resolveInjector())\n    .then(parseResult => {\n      this.parseResults.push(parseResult);\n      return parseResult;\n    });\n  }\n\n  /**\n   * Returns the injector for this scope\n   */\n  public async resolveInjector() {\n    this.checkIfDestroyed();\n\n    if (!this.injector) {\n      const parentInjector = this.parentScope ? await this.parentScope.resolveInjector() : undefined;\n      this._injector = await createInjector(this.providers, parentInjector);\n    }\n  \n    return this.injector!;\n  }\n\n  /**\n   * Destroys this scope and all of its created components\n   */\n  public destroy(): void {\n    this.checkIfDestroyed();\n\n    for (const parseResult of this.parseResults) {\n      parseResult.destroy();\n      allParseResults = allParseResults.filter(entry => entry !== parseResult);\n    }\n\n    if (this.injector) {\n      this.injector.destroy();\n    }\n\n    scopes = scopes.filter(scope => scope !== this);\n    this._isDestroyed = true;\n  }\n\n  private checkIfDestroyed() {\n    if (this.isDestroyed) {\n      throw new Error('This scope has already been destroyed. It or its methods cannot be used any longer.');\n    }\n  }\n}\n\n// parse\n// ----------\n\n/**\n * Parses content and loads components for all found hooks in standalone mode\n * \n * @param content - The content to parse\n * @param parsers - The parsers to use\n * @param context - An optional context object\n * @param options - An optional list of options\n * @param targetElement - An optional HTML element to use as the container for the loaded content.\n * @param targetHookIndex - An optional object to fill with the programmatic hook data. If none is provided, one is created and returned for you.\n * @param environmentInjector - An optional environmentInjector to use for the dynamically-loaded components. If none is provided, the default environmentInjector is used.\n */\nexport const parse = async (\n  content: any,\n  parsers: HookParserEntry[],\n  context: any = null,  \n  options: ParseOptions|null = null,\n  targetElement: HTMLElement|null = null,\n  targetHookIndex: HookIndex = {},\n  environmentInjector: EnvironmentInjector|null = null,\n): Promise<ParseResult> => {\n\n  // Reuse the same global injector for all independent parse calls\n  if (!environmentInjector) {\n    if (!sharedInjector) {\n      sharedInjector = await createInjector();\n    }\n    environmentInjector = sharedInjector;\n  }\n\n  // In standalone mode, emit HTML events from outputs by default\n  if (!options) {\n    options = {}\n  }\n  if (!options.hasOwnProperty('triggerDOMEvents')) {\n    options.triggerDOMEvents = true;\n  }\n\n  const dynHooksService = environmentInjector.get(DynamicHooksService);\n\n  // Needs to be run inside NgZone manually\n  return environmentInjector.get(NgZone).run(() => {\n    return firstValueFrom(dynHooksService\n      .parse(\n        content, \n        parsers,\n        context, \n        options, \n        null, \n        null,\n        targetElement, \n        targetHookIndex, \n        environmentInjector,\n        null\n      )\n    ).then(parseResult => {\n      allParseResults.push(parseResult);\n      return parseResult;\n    });\n  });\n}"]}