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.
123 lines • 21.1 kB
JavaScript
import { Injectable } from '@angular/core';
import * as i0 from "@angular/core";
import * as i1 from "../../services/utils/dataTypeParser";
import * as i2 from "../../services/utils/logger";
/**
* A helper service for the SelectorHookParsers that evaluates bindings and only updates them when needed so references are retained when possible
*/
export class BindingsValueManager {
constructor(dataTypeParser, logger) {
this.dataTypeParser = dataTypeParser;
this.logger = logger;
}
// Inputs
// -------------------------------------------------------------------------------------
/**
* Checks input bindings and evaluates/updates them as needed
*
* @param bindings - A list of @Input() bindings
* @param context - The current context object
* @param parserConfig - The parser config
* @param options - The current ParseOptions
*/
checkInputBindings(bindings, context, parserConfig, options) {
for (const [inputName, inputBinding] of Object.entries(bindings)) {
// If no need to parse, use raw as value
if (!parserConfig.parseInputs) {
inputBinding.value = inputBinding.raw;
}
else {
// If not yet parsed, do so
if (!inputBinding.parsed) {
try {
inputBinding.value = this.dataTypeParser.evaluate(inputBinding.raw, parserConfig.allowContextInBindings ? context : {}, undefined, parserConfig.unescapeStrings, inputBinding.boundContextVariables, parserConfig.allowContextFunctionCalls, options);
inputBinding.parsed = true;
}
catch (e) {
this.logger.error([`Hook input parsing error\nselector: ` + parserConfig.selector + `\ninput: ` + inputName + `\nvalue: "` + inputBinding.value + `"`], options);
this.logger.error([e.stack], options);
// If binding could not be parsed at all due to syntax error, remove from list of inputs.
// No amount of calls to updateInputBindings() will fix this kind of error.
delete bindings[inputName];
}
// Otherwise check if needs an update
}
else {
this.updateInputBindingIfStale(inputBinding, context, parserConfig);
}
}
}
}
/**
* We can detect if a binding needs to be reevaluated via the bound context variables. There are three cases to consider:
*
* a) If a binding does not use context vars, don't reevaluate (binding is static and won't ever need to be updated)
* b) If a binding does use context vars, but context vars haven't changed, don't reevaluate either (would evalute the same)
* c) If a binding uses context vars and they have changed, reevaluate the binding from scratch to get the new version
*
* This is in line with the standard Angular behavior when evaluating template vars like [input]="{prop: this.something}".
* When 'this.something' changes so that it returns false on a === comparison with its previous value, Angular does not
* simply replace the reference bound to 'prop', but recreates the whole object literal and passes a new reference into the
* input, triggering ngOnChanges.
*
* @param binding - The previous bindings
* @param context - The current context object
* @param parserConfig - The current parser config
*/
updateInputBindingIfStale(binding, context, parserConfig) {
if (Object.keys(binding.boundContextVariables).length > 0) {
// Check if bound context vars have changed
let boundContextVarHasChanged = false;
for (const [contextVarName, contextVarValue] of Object.entries(binding.boundContextVariables)) {
const encodedContextVarName = this.dataTypeParser.encodeDataTypeString(contextVarName);
// Compare with previous value
const newContextVarValue = this.dataTypeParser.loadContextVariable(encodedContextVarName, context, undefined, parserConfig.unescapeStrings, {}, parserConfig.allowContextFunctionCalls);
if (newContextVarValue !== contextVarValue) {
boundContextVarHasChanged = true;
break;
}
}
// Bound context var has changed! Reevaluate whole binding (which may include more than one context var, or point to some child property)
if (boundContextVarHasChanged) {
binding.boundContextVariables = {};
binding.value = this.dataTypeParser.evaluate(binding.raw, parserConfig.allowContextInBindings ? context : {}, undefined, parserConfig.unescapeStrings, binding.boundContextVariables, parserConfig.allowContextFunctionCalls);
}
}
}
// Outputs
// -------------------------------------------------------------------------------------
/**
* Checks output bindings and evaluates/updates them as needed
*
* @param bindings - A list of @Output() bindings
* @param parserConfig - The current parser config
* @param options - The current ParseOptions
*/
checkOutputBindings(bindings, parserConfig, options) {
for (const [outputName, outputBinding] of Object.entries(bindings)) {
// Unlike inputs, outputs only need to be created once by the parser, never updated, as you only create a wrapper function around the logic to execute.
// As this logic is run fresh whenever the output triggers, there is no need to replace this wrapper function on updates.
if (!outputBinding.parsed) {
outputBinding.value = (event, context) => {
try {
this.dataTypeParser.evaluate(outputBinding.raw, parserConfig.allowContextInBindings ? context : {}, event, parserConfig.unescapeStrings, outputBinding.boundContextVariables, parserConfig.allowContextFunctionCalls);
}
catch (e) {
this.logger.error([`Hook output parsing error\nselector: ` + parserConfig.selector + `\noutput: ` + outputName + `\nvalue: "` + outputBinding.value + `"`], options);
this.logger.error([e.stack], options);
}
};
outputBinding.parsed = true;
}
}
}
static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BindingsValueManager, deps: [{ token: i1.DataTypeParser }, { token: i2.Logger }], target: i0.ɵɵFactoryTarget.Injectable }); }
static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BindingsValueManager, providedIn: 'root' }); }
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: BindingsValueManager, decorators: [{
type: Injectable,
args: [{
providedIn: 'root'
}]
}], ctorParameters: () => [{ type: i1.DataTypeParser }, { type: i2.Logger }] });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bindingsValueManager.js","sourceRoot":"","sources":["../../../../../../projects/ngx-dynamic-hooks/src/lib/parsers/selector/bindingsValueManager.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\n\nimport { DataTypeParser } from '../../services/utils/dataTypeParser';\nimport { SelectorHookParserConfig } from './selectorHookParserConfig';\nimport { RichBindingData } from '../../interfaces';\nimport { Logger } from '../../services/utils/logger';\nimport { ParseOptions } from '../../services/settings/options';\n\n\n/**\n * A helper service for the SelectorHookParsers that evaluates bindings and only updates them when needed so references are retained when possible\n */\n@Injectable({\n  providedIn: 'root'\n})\nexport class BindingsValueManager {\n\n  constructor(private dataTypeParser: DataTypeParser, private logger: Logger) {\n  }\n\n  // Inputs\n  // -------------------------------------------------------------------------------------\n\n  /**\n   * Checks input bindings and evaluates/updates them as needed\n   *\n   * @param bindings - A list of @Input() bindings\n   * @param context - The current context object\n   * @param parserConfig - The parser config\n   * @param options - The current ParseOptions\n   */\n  checkInputBindings(bindings: {[key: string]: RichBindingData}, context: any, parserConfig: SelectorHookParserConfig, options: ParseOptions) {\n    for (const [inputName, inputBinding] of Object.entries(bindings)) {\n      // If no need to parse, use raw as value\n      if (!parserConfig.parseInputs) {\n        inputBinding.value = inputBinding.raw;\n    \n      } else {\n        // If not yet parsed, do so\n        if (!inputBinding.parsed) {\n          try {\n            inputBinding.value = this.dataTypeParser.evaluate(\n              inputBinding.raw,\n              parserConfig.allowContextInBindings ? context : {},\n              undefined,\n              parserConfig.unescapeStrings,\n              inputBinding.boundContextVariables,\n              parserConfig.allowContextFunctionCalls,\n              options\n            );\n            inputBinding.parsed = true;\n          } catch (e: any) {\n            this.logger.error([`Hook input parsing error\\nselector: ` + parserConfig.selector +  `\\ninput: ` + inputName + `\\nvalue: \"` + inputBinding.value + `\"`], options);\n            this.logger.error([e.stack], options);\n            // If binding could not be parsed at all due to syntax error, remove from list of inputs.\n            // No amount of calls to updateInputBindings() will fix this kind of error.\n            delete bindings[inputName];\n          }\n\n        // Otherwise check if needs an update\n        } else {\n          this.updateInputBindingIfStale(inputBinding, context, parserConfig);\n        }\n      }\n    }\n  }\n\n  /**\n   * We can detect if a binding needs to be reevaluated via the bound context variables. There are three cases to consider:\n   *\n   * a) If a binding does not use context vars, don't reevaluate (binding is static and won't ever need to be updated)\n   * b) If a binding does use context vars, but context vars haven't changed, don't reevaluate either (would evalute the same)\n   * c) If a binding uses context vars and they have changed, reevaluate the binding from scratch to get the new version\n   *\n   * This is in line with the standard Angular behavior when evaluating template vars like [input]=\"{prop: this.something}\".\n   * When 'this.something' changes so that it returns false on a === comparison with its previous value, Angular does not\n   * simply replace the reference bound to 'prop', but recreates the whole object literal and passes a new reference into the\n   * input, triggering ngOnChanges.\n   *\n   * @param binding - The previous bindings\n   * @param context - The current context object\n   * @param parserConfig - The current parser config\n   */\n  private updateInputBindingIfStale(binding: RichBindingData, context: any, parserConfig: SelectorHookParserConfig): void {\n\n    if (Object.keys(binding.boundContextVariables).length > 0) {\n      // Check if bound context vars have changed\n      let boundContextVarHasChanged = false;\n      for (const [contextVarName, contextVarValue] of Object.entries(binding.boundContextVariables)) {\n        const encodedContextVarName = this.dataTypeParser.encodeDataTypeString(contextVarName);\n        // Compare with previous value\n        const newContextVarValue = this.dataTypeParser.loadContextVariable(encodedContextVarName, context, undefined, parserConfig.unescapeStrings, {}, parserConfig.allowContextFunctionCalls);\n        if (newContextVarValue !== contextVarValue) {\n          boundContextVarHasChanged = true;\n          break;\n        }\n      }\n\n      // Bound context var has changed! Reevaluate whole binding (which may include more than one context var, or point to some child property)\n      if (boundContextVarHasChanged) {\n        binding.boundContextVariables = {};\n        binding.value = this.dataTypeParser.evaluate(\n          binding.raw,\n          parserConfig.allowContextInBindings ? context : {},\n          undefined,\n          parserConfig.unescapeStrings,\n          binding.boundContextVariables,\n          parserConfig.allowContextFunctionCalls\n        );\n      }\n    }\n  }\n\n  // Outputs\n  // -------------------------------------------------------------------------------------\n\n  /**\n   * Checks output bindings and evaluates/updates them as needed\n   *\n   * @param bindings - A list of @Output() bindings\n   * @param parserConfig - The current parser config\n   * @param options - The current ParseOptions\n   */\n  checkOutputBindings(bindings: {[key: string]: RichBindingData}, parserConfig: SelectorHookParserConfig, options: ParseOptions) {\n    for (const [outputName, outputBinding] of Object.entries(bindings)) {\n      // Unlike inputs, outputs only need to be created once by the parser, never updated, as you only create a wrapper function around the logic to execute.\n      // As this logic is run fresh whenever the output triggers, there is no need to replace this wrapper function on updates.\n      if (!outputBinding.parsed) {\n        outputBinding.value = (event: any, context: any) => {\n          try {\n            this.dataTypeParser.evaluate(\n              outputBinding.raw,\n              parserConfig.allowContextInBindings ? context : {},\n              event,\n              parserConfig.unescapeStrings,\n              outputBinding.boundContextVariables,\n              parserConfig.allowContextFunctionCalls\n            );\n          } catch (e: any) {\n            this.logger.error([`Hook output parsing error\\nselector: ` + parserConfig.selector +  `\\noutput: ` + outputName + `\\nvalue: \"` + outputBinding.value + `\"`], options);\n            this.logger.error([e.stack], options);\n          }\n        };\n        outputBinding.parsed = true;\n      }\n    }\n  }\n\n}\n"]}