@thomas-siegfried/tapout 0.0.1

package/src/bindingProvider.ts

@@ -0,0 +1,260 @@
+import type { BindingContext } from './bindingContext.js';
+import type { AllBindingsAccessor } from './expressionRewriting.js';
+export type { AllBindingsAccessor } from './expressionRewriting.js';
+import { preProcessBindings } from './expressionRewriting.js';
+import { hasBindingValue, virtualNodeBindingValue } from './virtualElements.js';
+import { unwrapObservable } from './utils.js';
+
+const DATA_BIND_ATTR = 'data-bind';
+
+// ---- Binding Handler Interface ----
+
+export interface BindingHandler {
+  init?(
+    node: Node,
+    valueAccessor: () => unknown,
+    allBindings: AllBindingsAccessor,
+    viewModel: unknown,
+    bindingContext: BindingContext,
+  ): void | { controlsDescendantBindings: boolean };
+
+  update?(
+    node: Node,
+    valueAccessor: () => unknown,
+    allBindings: AllBindingsAccessor,
+    viewModel: unknown,
+    bindingContext: BindingContext,
+  ): void;
+
+  preprocess?(
+    value: string,
+    key: string,
+    addBinding: (key: string, val: string) => void,
+  ): string | void;
+
+  after?: string[];
+
+  getNamespacedHandler?(name: string, namespace: string, namespacedName: string): BindingHandler;
+}
+
+// ---- Binding Handler Registry ----
+
+export const bindingHandlers: Record<string, BindingHandler> = {};
+
+let _getBindingHandlerImpl = (key: string): BindingHandler | undefined => bindingHandlers[key];
+
+export function getBindingHandler(key: string): BindingHandler | undefined {
+  return _getBindingHandlerImpl(key);
+}
+
+// ---- Preprocessor Infrastructure ----
+
+export type PreprocessFn = (
+  value: string,
+  key: string,
+  addBinding: (key: string, val: string) => void,
+) => string | void;
+
+export type NodePreprocessFn = (node: Node) => Node[] | void;
+
+function getOrCreateHandler(bindingKeyOrHandler: string | BindingHandler): BindingHandler {
+  if (typeof bindingKeyOrHandler === 'object') return bindingKeyOrHandler;
+  return getBindingHandler(bindingKeyOrHandler) || (bindingHandlers[bindingKeyOrHandler] = {});
+}
+
+export function chainPreprocessor(
+  handler: BindingHandler,
+  fn: PreprocessFn,
+): BindingHandler {
+  const previous = handler.preprocess;
+  if (previous) {
+    handler.preprocess = function (value, key, addBinding) {
+      const result = previous(value, key, addBinding);
+      if (result !== undefined) {
+        return fn(result, key, addBinding);
+      }
+    };
+  } else {
+    handler.preprocess = fn;
+  }
+  return handler;
+}
+
+export function addBindingPreprocessor(
+  bindingKeyOrHandler: string | BindingHandler,
+  preprocessFn: PreprocessFn,
+): BindingHandler {
+  return chainPreprocessor(getOrCreateHandler(bindingKeyOrHandler), preprocessFn);
+}
+
+export function addNodePreprocessor(preprocessFn: NodePreprocessFn): void {
+  const provider = instance;
+  const previous = provider.preprocessNode;
+  if (previous) {
+    provider.preprocessNode = function (node: Node): Node[] | void {
+      const newNodes = previous.call(this, node);
+      if (!newNodes) {
+        return preprocessFn.call(this, node);
+      }
+      return newNodes;
+    };
+  } else {
+    provider.preprocessNode = preprocessFn;
+  }
+}
+
+export function addBindingHandlerCreator(
+  matchRegex: RegExp,
+  callbackFn: (match: RegExpMatchArray, bindingKey: string) => BindingHandler | undefined,
+): void {
+  const previousImpl = _getBindingHandlerImpl;
+  _getBindingHandlerImpl = (key) => {
+    const existing = previousImpl(key);
+    if (existing) return existing;
+    const match = key.match(matchRegex);
+    return match ? callbackFn(match, key) : undefined;
+  };
+}
+
+// ---- Filters Registry (injected by filters module) ----
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+let _filters: Record<string, Function> = {};
+
+// eslint-disable-next-line @typescript-eslint/no-unsafe-function-type
+export function setFiltersRegistry(filters: Record<string, Function>): void {
+  _filters = filters;
+}
+
+// ---- Compiled Binding Function Cache ----
+
+type BindingEvaluator = (context: BindingContext, element: Node) => Record<string, unknown> | null;
+
+function createBindingsStringEvaluator(
+  bindingsString: string,
+  options?: { valueAccessors?: boolean },
+): BindingEvaluator {
+  const rewrittenBindings = preProcessBindings(bindingsString, {
+    valueAccessors: options?.valueAccessors,
+    getBindingHandler,
+  });
+  const functionBody = "with($context){with($data||{}){return{" + rewrittenBindings + "}}}";
+  // eslint-disable-next-line @typescript-eslint/no-implied-eval, no-new-func
+  const innerFn = new Function("$context", "$element", "$unwrap", "$filters", functionBody) as
+    (context: BindingContext, element: Node, unwrap: typeof unwrapObservable, filters: Record<string, Function>) => Record<string, unknown> | null;
+  return (context, element) => innerFn(context, element, unwrapObservable, _filters);
+}
+
+function createBindingsStringEvaluatorViaCache(
+  bindingsString: string,
+  cache: Record<string, BindingEvaluator>,
+  options?: { valueAccessors?: boolean },
+): BindingEvaluator {
+  const cacheKey = bindingsString + (options?.valueAccessors ? 'true' : '');
+  return cache[cacheKey] || (cache[cacheKey] = createBindingsStringEvaluator(bindingsString, options));
+}
+
+// ---- Custom Element Hook (set by componentBinding.ts to avoid circular imports) ----
+
+export type GetComponentNameForNodeFn = (node: Node) => string | undefined;
+export type AddBindingsForCustomElementFn = (
+  allBindings: Record<string, unknown> | null,
+  node: Node,
+  bindingContext: BindingContext,
+  valueAccessors?: boolean,
+) => Record<string, unknown> | null;
+
+let _getComponentNameForNode: GetComponentNameForNodeFn | undefined;
+let _addBindingsForCustomElement: AddBindingsForCustomElementFn | undefined;
+
+export function setCustomElementHooks(
+  getComponentNameForNode: GetComponentNameForNodeFn,
+  addBindingsForCustomElement: AddBindingsForCustomElementFn,
+): void {
+  _getComponentNameForNode = getComponentNameForNode;
+  _addBindingsForCustomElement = addBindingsForCustomElement;
+}
+
+// ---- Binding Provider ----
+
+export class BindingProvider {
+  bindingCache: Record<string, BindingEvaluator> = {};
+  preprocessNode?: NodePreprocessFn;
+
+  nodeHasBindings(node: Node): boolean {
+    switch (node.nodeType) {
+      case 1: // Element
+        return (node as Element).getAttribute(DATA_BIND_ATTR) != null
+          || !!(_getComponentNameForNode && _getComponentNameForNode(node));
+      case 8: // Comment
+        return hasBindingValue(node);
+      default:
+        return false;
+    }
+  }
+
+  getBindingsString(node: Node): string | null {
+    switch (node.nodeType) {
+      case 1: // Element
+        return (node as Element).getAttribute(DATA_BIND_ATTR);
+      case 8: // Comment
+        return virtualNodeBindingValue(node);
+      default:
+        return null;
+    }
+  }
+
+  getBindingAccessors(
+    node: Node,
+    bindingContext: BindingContext,
+  ): Record<string, () => unknown> | null {
+    const bindingsString = this.getBindingsString(node);
+    let result = bindingsString
+      ? this.parseBindingsString(bindingsString, bindingContext, node, { valueAccessors: true }) as Record<string, () => unknown> | null
+      : null;
+
+    if (_addBindingsForCustomElement) {
+      result = _addBindingsForCustomElement(result, node, bindingContext, true) as typeof result;
+    }
+
+    return result;
+  }
+
+  getBindings(
+    node: Node,
+    bindingContext: BindingContext,
+  ): Record<string, unknown> | null {
+    const bindingsString = this.getBindingsString(node);
+    let result = bindingsString
+      ? this.parseBindingsString(bindingsString, bindingContext, node)
+      : null;
+
+    if (_addBindingsForCustomElement) {
+      result = _addBindingsForCustomElement(result, node, bindingContext, false) as typeof result;
+    }
+
+    return result;
+  }
+
+  parseBindingsString(
+    bindingsString: string,
+    bindingContext: BindingContext,
+    node: Node,
+    options?: { valueAccessors?: boolean },
+  ): Record<string, unknown> | null {
+    try {
+      const bindingFunction = createBindingsStringEvaluatorViaCache(
+        bindingsString,
+        this.bindingCache,
+        options,
+      );
+      return bindingFunction(bindingContext, node);
+    } catch (ex) {
+      const err = ex as Error;
+      err.message = "Unable to parse bindings.\nBindings value: " + bindingsString + "\nMessage: " + err.message;
+      throw err;
+    }
+  }
+}
+
+export const instance = new BindingProvider();