@thomas-siegfried/tapout 0.0.1 → 0.0.2

package/src/interpolationMarkup.ts

@@ -1,130 +1,130 @@
-import { addNodePreprocessor } from './bindingProvider.js';
-import type { NodePreprocessFn } from './bindingProvider.js';
-import { options } from './options.js';
-
-// ---- Interpolation Parser ----
-
-// Parses text containing {{ }} markup into alternating plain-text and expression segments.
-// Uses a recursive inside-out approach: finds the outermost {{ and }} pair, then
-// recursively parses the inner text to handle nested {{ }} correctly.
-export function parseInterpolationMarkup(
-  textToParse: string,
-  outerTextCallback: (text: string) => void,
-  expressionCallback: (expression: string) => void,
-): void {
-  function innerParse(text: string): void {
-    const innerMatch = text.match(/^([\s\S]*)}}([\s\S]*?)\{\{([\s\S]*)$/);
-    if (innerMatch) {
-      innerParse(innerMatch[1]);
-      outerTextCallback(innerMatch[2]);
-      expressionCallback(innerMatch[3]);
-    } else {
-      expressionCallback(text);
-    }
-  }
-
-  const outerMatch = textToParse.match(/^([\s\S]*?)\{\{([\s\S]*)}}([\s\S]*)$/);
-  if (outerMatch) {
-    outerTextCallback(outerMatch[1]);
-    innerParse(outerMatch[2]);
-    outerTextCallback(outerMatch[3]);
-  }
-}
-
-function trim(s: string | null | undefined): string {
-  return s == null ? '' : s.trim();
-}
-
-// ---- Expression → Comment Nodes ----
-
-// Converts a parsed expression into comment-based binding nodes.
-//   {{ expr }}        → <!-- tap text: expr --><!-- /tap -->
-//   {{{ expr }}}      → <!-- tap html: expr --><!-- /tap -->
-//   {{# if cond }}    → <!-- tap if: cond -->
-//   {{# if cond /}}   → <!-- tap if: cond --><!-- /tap -->  (self-closing)
-//   {{/ }}            → <!-- /tap -->
-export function wrapExpression(expressionText: string, node?: Node): Node[] {
-  const ownerDocument = node?.ownerDocument ?? document;
-  let closeComment = true;
-  let binding: string | undefined;
-  expressionText = trim(expressionText);
-
-  const firstChar = expressionText[0];
-  const lastChar = expressionText[expressionText.length - 1];
-  const result: Node[] = [];
-
-  if (firstChar === '#') {
-    if (lastChar === '/') {
-      binding = trim(expressionText.slice(1, -1));
-    } else {
-      binding = trim(expressionText.slice(1));
-      closeComment = false;
-    }
-    const matches = binding.match(/^([^,"'{}()\/:[\]\s]+)\s+([^\s:].*)/);
-    if (matches) {
-      binding = matches[1] + ':' + matches[2];
-    }
-  } else if (firstChar === '/') {
-    // Closing tag — just emit the end comment
-  } else if (firstChar === '{' && lastChar === '}') {
-    binding = 'html:' + trim(expressionText.slice(1, -1));
-  } else {
-    binding = 'text:' + trim(expressionText);
-  }
-
-  if (binding) {
-    result.push(ownerDocument.createComment(' tap ' + binding + ' '));
-  }
-  if (closeComment) {
-    result.push(ownerDocument.createComment(' /tap '));
-  }
-
-  return result;
-}
-
-// ---- Node Preprocessor ----
-
-export const interpolationMarkupPreprocessor: NodePreprocessFn = function (node: Node): Node[] | void {
-  if (
-    node.nodeType !== 3 ||
-    !node.nodeValue ||
-    node.nodeValue.indexOf('{{') === -1 ||
-    (node.parentNode && (node.parentNode as Element).nodeName === 'TEXTAREA')
-  ) {
-    return;
-  }
-
-  const nodes: Node[] = [];
-
-  function addTextNode(text: string): void {
-    if (text) {
-      nodes.push(node.ownerDocument!.createTextNode(text));
-    }
-  }
-
-  function addExpressionNodes(expressionText: string): void {
-    if (expressionText) {
-      nodes.push(...wrapExpression(expressionText, node));
-    }
-  }
-
-  parseInterpolationMarkup(node.nodeValue, addTextNode, addExpressionNodes);
-
-  if (nodes.length) {
-    if (node.parentNode) {
-      const parent = node.parentNode;
-      for (const newNode of nodes) {
-        parent.insertBefore(newNode, node);
-      }
-      parent.removeChild(node);
-    }
-    return nodes;
-  }
-};
-
-// ---- Enable ----
-
-export function enableInterpolationMarkup(): void {
-  options.interpolation = true;
-  addNodePreprocessor(interpolationMarkupPreprocessor);
-}
+import { addNodePreprocessor } from './bindingProvider.js';
+import type { NodePreprocessFn } from './bindingProvider.js';
+import { options } from './options.js';
+
+// ---- Interpolation Parser ----
+
+// Parses text containing {{ }} markup into alternating plain-text and expression segments.
+// Uses a recursive inside-out approach: finds the outermost {{ and }} pair, then
+// recursively parses the inner text to handle nested {{ }} correctly.
+export function parseInterpolationMarkup(
+  textToParse: string,
+  outerTextCallback: (text: string) => void,
+  expressionCallback: (expression: string) => void,
+): void {
+  function innerParse(text: string): void {
+    const innerMatch = text.match(/^([\s\S]*)}}([\s\S]*?)\{\{([\s\S]*)$/);
+    if (innerMatch) {
+      innerParse(innerMatch[1]);
+      outerTextCallback(innerMatch[2]);
+      expressionCallback(innerMatch[3]);
+    } else {
+      expressionCallback(text);
+    }
+  }
+
+  const outerMatch = textToParse.match(/^([\s\S]*?)\{\{([\s\S]*)}}([\s\S]*)$/);
+  if (outerMatch) {
+    outerTextCallback(outerMatch[1]);
+    innerParse(outerMatch[2]);
+    outerTextCallback(outerMatch[3]);
+  }
+}
+
+function trim(s: string | null | undefined): string {
+  return s == null ? '' : s.trim();
+}
+
+// ---- Expression → Comment Nodes ----
+
+// Converts a parsed expression into comment-based binding nodes.
+//   {{ expr }}        → <!-- tap text: expr --><!-- /tap -->
+//   {{{ expr }}}      → <!-- tap html: expr --><!-- /tap -->
+//   {{# if cond }}    → <!-- tap if: cond -->
+//   {{# if cond /}}   → <!-- tap if: cond --><!-- /tap -->  (self-closing)
+//   {{/ }}            → <!-- /tap -->
+export function wrapExpression(expressionText: string, node?: Node): Node[] {
+  const ownerDocument = node?.ownerDocument ?? document;
+  let closeComment = true;
+  let binding: string | undefined;
+  expressionText = trim(expressionText);
+
+  const firstChar = expressionText[0];
+  const lastChar = expressionText[expressionText.length - 1];
+  const result: Node[] = [];
+
+  if (firstChar === '#') {
+    if (lastChar === '/') {
+      binding = trim(expressionText.slice(1, -1));
+    } else {
+      binding = trim(expressionText.slice(1));
+      closeComment = false;
+    }
+    const matches = binding.match(/^([^,"'{}()\/:[\]\s]+)\s+([^\s:].*)/);
+    if (matches) {
+      binding = matches[1] + ':' + matches[2];
+    }
+  } else if (firstChar === '/') {
+    // Closing tag — just emit the end comment
+  } else if (firstChar === '{' && lastChar === '}') {
+    binding = 'html:' + trim(expressionText.slice(1, -1));
+  } else {
+    binding = 'text:' + trim(expressionText);
+  }
+
+  if (binding) {
+    result.push(ownerDocument.createComment(' tap ' + binding + ' '));
+  }
+  if (closeComment) {
+    result.push(ownerDocument.createComment(' /tap '));
+  }
+
+  return result;
+}
+
+// ---- Node Preprocessor ----
+
+export const interpolationMarkupPreprocessor: NodePreprocessFn = function (node: Node): Node[] | void {
+  if (
+    node.nodeType !== 3 ||
+    !node.nodeValue ||
+    node.nodeValue.indexOf('{{') === -1 ||
+    (node.parentNode && (node.parentNode as Element).nodeName === 'TEXTAREA')
+  ) {
+    return;
+  }
+
+  const nodes: Node[] = [];
+
+  function addTextNode(text: string): void {
+    if (text) {
+      nodes.push(node.ownerDocument!.createTextNode(text));
+    }
+  }
+
+  function addExpressionNodes(expressionText: string): void {
+    if (expressionText) {
+      nodes.push(...wrapExpression(expressionText, node));
+    }
+  }
+
+  parseInterpolationMarkup(node.nodeValue, addTextNode, addExpressionNodes);
+
+  if (nodes.length) {
+    if (node.parentNode) {
+      const parent = node.parentNode;
+      for (const newNode of nodes) {
+        parent.insertBefore(newNode, node);
+      }
+      parent.removeChild(node);
+    }
+    return nodes;
+  }
+};
+
+// ---- Enable ----
+
+export function enableInterpolationMarkup(): void {
+  options.interpolation = true;
+  addNodePreprocessor(interpolationMarkupPreprocessor);
+}

package/src/memoization.ts

@@ -1,71 +1,71 @@
-type MemoCallback = (...args: unknown[]) => void;
-
-const memos = new Map<string, MemoCallback>();
-
-function randomMax8HexChars(): string {
-  return (((1 + Math.random()) * 0x100000000) | 0).toString(16).substring(1);
-}
-
-function generateRandomId(): string {
-  return randomMax8HexChars() + randomMax8HexChars();
-}
-
-function findMemoNodes(
-  rootNode: Node | null,
-  appendToArray: { domNode: Comment; memoId: string }[],
-): void {
-  if (!rootNode) return;
-  if (rootNode.nodeType === 8) {
-    const memoId = parseMemoText(rootNode.nodeValue || '');
-    if (memoId != null)
-      appendToArray.push({ domNode: rootNode as Comment, memoId });
-  } else if (rootNode.nodeType === 1) {
-    const childNodes = rootNode.childNodes;
-    for (let i = 0; i < childNodes.length; i++)
-      findMemoNodes(childNodes[i], appendToArray);
-  }
-}
-
-export function memoize(callback: MemoCallback): string {
-  if (typeof callback !== 'function')
-    throw new Error('You can only pass a function to memoize()');
-  const memoId = generateRandomId();
-  memos.set(memoId, callback);
-  return '<!--[tap_memo:' + memoId + ']-->';
-}
-
-export function unmemoize(memoId: string, callbackParams?: unknown[]): boolean {
-  const callback = memos.get(memoId);
-  if (callback === undefined)
-    throw new Error("Couldn't find any memo with ID " + memoId + ". Perhaps it's already been unmemoized.");
-  try {
-    callback.apply(null, callbackParams || []);
-    return true;
-  } finally {
-    memos.delete(memoId);
-  }
-}
-
-export function unmemoizeDomNodeAndDescendants(
-  domNode: Node,
-  extraCallbackParamsArray?: unknown[],
-): void {
-  const found: { domNode: Comment; memoId: string }[] = [];
-  findMemoNodes(domNode, found);
-  for (const { domNode: node, memoId } of found) {
-    const combinedParams: unknown[] = [node];
-    if (extraCallbackParamsArray)
-      combinedParams.push(...extraCallbackParamsArray);
-    unmemoize(memoId, combinedParams);
-    node.nodeValue = '';
-    if (node.parentNode)
-      node.parentNode.removeChild(node);
-  }
-}
-
-const memoTextRegex = /^\[tap_memo:(.*?)\]$/;
-
-export function parseMemoText(memoText: string): string | null {
-  const match = memoText.match(memoTextRegex);
-  return match ? match[1] : null;
-}
+type MemoCallback = (...args: unknown[]) => void;
+
+const memos = new Map<string, MemoCallback>();
+
+function randomMax8HexChars(): string {
+  return (((1 + Math.random()) * 0x100000000) | 0).toString(16).substring(1);
+}
+
+function generateRandomId(): string {
+  return randomMax8HexChars() + randomMax8HexChars();
+}
+
+function findMemoNodes(
+  rootNode: Node | null,
+  appendToArray: { domNode: Comment; memoId: string }[],
+): void {
+  if (!rootNode) return;
+  if (rootNode.nodeType === 8) {
+    const memoId = parseMemoText(rootNode.nodeValue || '');
+    if (memoId != null)
+      appendToArray.push({ domNode: rootNode as Comment, memoId });
+  } else if (rootNode.nodeType === 1) {
+    const childNodes = rootNode.childNodes;
+    for (let i = 0; i < childNodes.length; i++)
+      findMemoNodes(childNodes[i], appendToArray);
+  }
+}
+
+export function memoize(callback: MemoCallback): string {
+  if (typeof callback !== 'function')
+    throw new Error('You can only pass a function to memoize()');
+  const memoId = generateRandomId();
+  memos.set(memoId, callback);
+  return '<!--[tap_memo:' + memoId + ']-->';
+}
+
+export function unmemoize(memoId: string, callbackParams?: unknown[]): boolean {
+  const callback = memos.get(memoId);
+  if (callback === undefined)
+    throw new Error("Couldn't find any memo with ID " + memoId + ". Perhaps it's already been unmemoized.");
+  try {
+    callback.apply(null, callbackParams || []);
+    return true;
+  } finally {
+    memos.delete(memoId);
+  }
+}
+
+export function unmemoizeDomNodeAndDescendants(
+  domNode: Node,
+  extraCallbackParamsArray?: unknown[],
+): void {
+  const found: { domNode: Comment; memoId: string }[] = [];
+  findMemoNodes(domNode, found);
+  for (const { domNode: node, memoId } of found) {
+    const combinedParams: unknown[] = [node];
+    if (extraCallbackParamsArray)
+      combinedParams.push(...extraCallbackParamsArray);
+    unmemoize(memoId, combinedParams);
+    node.nodeValue = '';
+    if (node.parentNode)
+      node.parentNode.removeChild(node);
+  }
+}
+
+const memoTextRegex = /^\[tap_memo:(.*?)\]$/;
+
+export function parseMemoText(memoText: string): string | null {
+  const match = memoText.match(memoTextRegex);
+  return match ? match[1] : null;
+}

package/src/namespacedBindings.ts

@@ -1,132 +1,132 @@
-import {
-  bindingHandlers,
-  getBindingHandler,
-  addBindingHandlerCreator,
-  addBindingPreprocessor,
-} from './bindingProvider.js';
-import type { BindingHandler, PreprocessFn } from './bindingProvider.js';
-import { allowedVirtualElementBindings } from './virtualElements.js';
-import { parseObjectLiteral } from './expressionRewriting.js';
-import type { BindingContext } from './bindingContext.js';
-import { options } from './options.js';
-import type { AllBindingsAccessor } from './expressionRewriting.js';
-
-const NAMESPACE_DIVIDER = '.';
-const NAMESPACED_BINDING_REGEX = /^([^.]+)\.(.+)$/;
-
-// Translates `namespace.name: value` into `namespace: {name: value}`.
-// This works because attr/css/style/event all accept an object map.
-export function defaultGetNamespacedHandler(
-  this: BindingHandler,
-  name: string,
-  namespace: string,
-  namespacedName: string,
-): BindingHandler {
-  const handler: BindingHandler = Object.assign({}, this);
-
-  function makeSubValueAccessor(valueAccessor: () => unknown): () => Record<string, unknown> {
-    return () => {
-      const result: Record<string, unknown> = {};
-      result[name] = valueAccessor();
-      return result;
-    };
-  }
-
-  if (handler.init) {
-    handler.init = function (
-      element: Node,
-      valueAccessor: () => unknown,
-      allBindings: AllBindingsAccessor,
-      viewModel: unknown,
-      bindingContext: BindingContext,
-    ) {
-      return bindingHandlers[namespace].init!.call(
-        this, element, makeSubValueAccessor(valueAccessor), allBindings, viewModel, bindingContext,
-      );
-    };
-  }
-
-  if (handler.update) {
-    handler.update = function (
-      element: Node,
-      valueAccessor: () => unknown,
-      allBindings: AllBindingsAccessor,
-      viewModel: unknown,
-      bindingContext: BindingContext,
-    ) {
-      bindingHandlers[namespace].update!.call(
-        this, element, makeSubValueAccessor(valueAccessor), allBindings, viewModel, bindingContext,
-      );
-    };
-  }
-
-  handler.preprocess = undefined;
-
-  if (allowedVirtualElementBindings[namespace]) {
-    allowedVirtualElementBindings[namespacedName] = true;
-  }
-
-  return handler;
-}
-
-// Register the dynamic handler creator for the `namespace.name` pattern.
-// When `getBindingHandler('attr.href')` is called and no explicit handler exists,
-// this splits on `.`, finds the `attr` handler, and creates a derived handler
-// that wraps the single value into the object map format the namespace handler expects.
-export function enableNamespacedBindings(): void {
-  options.namespacedBindings = true;
-  addBindingHandlerCreator(NAMESPACED_BINDING_REGEX, (match, bindingKey) => {
-    const namespace = match[1];
-    const namespaceHandler = bindingHandlers[namespace];
-    if (namespaceHandler) {
-      const name = match[2];
-      const handlerFn = namespaceHandler.getNamespacedHandler || defaultGetNamespacedHandler;
-      const handler = handlerFn.call(namespaceHandler, name, namespace, bindingKey);
-      bindingHandlers[bindingKey] = handler;
-      return handler;
-    }
-    return undefined;
-  });
-}
-
-// Preprocessor that auto-expands `binding: {key: val, key2: val2}` into
-// individual `binding.key: val` and `binding.key2: val2` bindings.
-export const autoNamespacedPreprocessor: PreprocessFn = function (
-  value: string,
-  binding: string,
-  addBinding: (key: string, val: string) => void,
-): string | void {
-  if (value.charAt(0) !== '{') return value;
-
-  const subBindings = parseObjectLiteral(value);
-  for (const kv of subBindings) {
-    addBinding(binding + NAMESPACE_DIVIDER + (kv.key || kv.unknown || ''), kv.value || '');
-  }
-};
-
-// Enable the auto-expand preprocessor for a specific binding, so
-// `attr: {href: url, title: tip}` auto-expands to `attr.href: url, attr.title: tip`.
-export function enableAutoNamespacedSyntax(bindingKeyOrHandler: string | BindingHandler): void {
-  addBindingPreprocessor(bindingKeyOrHandler, autoNamespacedPreprocessor);
-}
-
-// Add a preprocessor to all dynamically-generated namespaced handlers under a namespace.
-// For example, adding a filter preprocessor to 'attr' would make it apply to
-// every `attr.x` binding that gets created.
-export function addDefaultNamespacedBindingPreprocessor(
-  namespace: string,
-  preprocessFn: PreprocessFn,
-): void {
-  const handler = getBindingHandler(namespace);
-  if (handler) {
-    const previousHandlerFn = handler.getNamespacedHandler || defaultGetNamespacedHandler;
-    handler.getNamespacedHandler = function (
-      name: string,
-      ns: string,
-      namespacedName: string,
-    ): BindingHandler {
-      const created = previousHandlerFn.call(this, name, ns, namespacedName);
-      return addBindingPreprocessor(created, preprocessFn);
-    };
-  }
-}
+import {
+  bindingHandlers,
+  getBindingHandler,
+  addBindingHandlerCreator,
+  addBindingPreprocessor,
+} from './bindingProvider.js';
+import type { BindingHandler, PreprocessFn } from './bindingProvider.js';
+import { allowedVirtualElementBindings } from './virtualElements.js';
+import { parseObjectLiteral } from './expressionRewriting.js';
+import type { BindingContext } from './bindingContext.js';
+import { options } from './options.js';
+import type { AllBindingsAccessor } from './expressionRewriting.js';
+
+const NAMESPACE_DIVIDER = '.';
+const NAMESPACED_BINDING_REGEX = /^([^.]+)\.(.+)$/;
+
+// Translates `namespace.name: value` into `namespace: {name: value}`.
+// This works because attr/css/style/event all accept an object map.
+export function defaultGetNamespacedHandler(
+  this: BindingHandler,
+  name: string,
+  namespace: string,
+  namespacedName: string,
+): BindingHandler {
+  const handler: BindingHandler = Object.assign({}, this);
+
+  function makeSubValueAccessor(valueAccessor: () => unknown): () => Record<string, unknown> {
+    return () => {
+      const result: Record<string, unknown> = {};
+      result[name] = valueAccessor();
+      return result;
+    };
+  }
+
+  if (handler.init) {
+    handler.init = function (
+      element: Node,
+      valueAccessor: () => unknown,
+      allBindings: AllBindingsAccessor,
+      viewModel: unknown,
+      bindingContext: BindingContext,
+    ) {
+      return bindingHandlers[namespace].init!.call(
+        this, element, makeSubValueAccessor(valueAccessor), allBindings, viewModel, bindingContext,
+      );
+    };
+  }
+
+  if (handler.update) {
+    handler.update = function (
+      element: Node,
+      valueAccessor: () => unknown,
+      allBindings: AllBindingsAccessor,
+      viewModel: unknown,
+      bindingContext: BindingContext,
+    ) {
+      bindingHandlers[namespace].update!.call(
+        this, element, makeSubValueAccessor(valueAccessor), allBindings, viewModel, bindingContext,
+      );
+    };
+  }
+
+  handler.preprocess = undefined;
+
+  if (allowedVirtualElementBindings[namespace]) {
+    allowedVirtualElementBindings[namespacedName] = true;
+  }
+
+  return handler;
+}
+
+// Register the dynamic handler creator for the `namespace.name` pattern.
+// When `getBindingHandler('attr.href')` is called and no explicit handler exists,
+// this splits on `.`, finds the `attr` handler, and creates a derived handler
+// that wraps the single value into the object map format the namespace handler expects.
+export function enableNamespacedBindings(): void {
+  options.namespacedBindings = true;
+  addBindingHandlerCreator(NAMESPACED_BINDING_REGEX, (match, bindingKey) => {
+    const namespace = match[1];
+    const namespaceHandler = bindingHandlers[namespace];
+    if (namespaceHandler) {
+      const name = match[2];
+      const handlerFn = namespaceHandler.getNamespacedHandler || defaultGetNamespacedHandler;
+      const handler = handlerFn.call(namespaceHandler, name, namespace, bindingKey);
+      bindingHandlers[bindingKey] = handler;
+      return handler;
+    }
+    return undefined;
+  });
+}
+
+// Preprocessor that auto-expands `binding: {key: val, key2: val2}` into
+// individual `binding.key: val` and `binding.key2: val2` bindings.
+export const autoNamespacedPreprocessor: PreprocessFn = function (
+  value: string,
+  binding: string,
+  addBinding: (key: string, val: string) => void,
+): string | void {
+  if (value.charAt(0) !== '{') return value;
+
+  const subBindings = parseObjectLiteral(value);
+  for (const kv of subBindings) {
+    addBinding(binding + NAMESPACE_DIVIDER + (kv.key || kv.unknown || ''), kv.value || '');
+  }
+};
+
+// Enable the auto-expand preprocessor for a specific binding, so
+// `attr: {href: url, title: tip}` auto-expands to `attr.href: url, attr.title: tip`.
+export function enableAutoNamespacedSyntax(bindingKeyOrHandler: string | BindingHandler): void {
+  addBindingPreprocessor(bindingKeyOrHandler, autoNamespacedPreprocessor);
+}
+
+// Add a preprocessor to all dynamically-generated namespaced handlers under a namespace.
+// For example, adding a filter preprocessor to 'attr' would make it apply to
+// every `attr.x` binding that gets created.
+export function addDefaultNamespacedBindingPreprocessor(
+  namespace: string,
+  preprocessFn: PreprocessFn,
+): void {
+  const handler = getBindingHandler(namespace);
+  if (handler) {
+    const previousHandlerFn = handler.getNamespacedHandler || defaultGetNamespacedHandler;
+    handler.getNamespacedHandler = function (
+      name: string,
+      ns: string,
+      namespacedName: string,
+    ): BindingHandler {
+      const created = previousHandlerFn.call(this, name, ns, namespacedName);
+      return addBindingPreprocessor(created, preprocessFn);
+    };
+  }
+}