@thomas-siegfried/tapout 0.0.1 → 0.0.2

package/src/configure.ts

@@ -1,52 +1,52 @@
-import { options } from './options.js';
-import { bindingHandlers, instance as providerInstance } from './bindingProvider.js';
-import { enableInterpolationMarkup } from './interpolationMarkup.js';
-import { enableAttributeInterpolationMarkup } from './attributeInterpolationMarkup.js';
-import { enableNamespacedBindings } from './namespacedBindings.js';
-import { enableTextFilter } from './filters.js';
-
-let _enabledInterpolation = false;
-let _enabledAttributeInterpolation = false;
-let _enabledNamespacedBindings = false;
-let _enabledFilters = false;
-
-function enableFiltersGlobal(): void {
-  for (const key of Object.keys(bindingHandlers)) {
-    enableTextFilter(key);
-  }
-}
-
-export function ensureConfigured(): void {
-  if (options.interpolation && !_enabledInterpolation) {
-    _enabledInterpolation = true;
-    enableInterpolationMarkup();
-  }
-  if (options.attributeInterpolation && !_enabledAttributeInterpolation) {
-    _enabledAttributeInterpolation = true;
-    enableAttributeInterpolationMarkup();
-  }
-  if (options.namespacedBindings && !_enabledNamespacedBindings) {
-    _enabledNamespacedBindings = true;
-    enableNamespacedBindings();
-  }
-  if (options.filters && !_enabledFilters) {
-    _enabledFilters = true;
-    enableFiltersGlobal();
-  }
-}
-
-export function resetConfigured(): void {
-  _enabledInterpolation = false;
-  _enabledAttributeInterpolation = false;
-  _enabledNamespacedBindings = false;
-  _enabledFilters = false;
-  providerInstance.bindingCache = {};
-}
-
-export function enableAll(): void {
-  options.interpolation = true;
-  options.attributeInterpolation = true;
-  options.namespacedBindings = true;
-  options.filters = true;
-  ensureConfigured();
-}
+import { options } from './options.js';
+import { bindingHandlers, instance as providerInstance } from './bindingProvider.js';
+import { enableInterpolationMarkup } from './interpolationMarkup.js';
+import { enableAttributeInterpolationMarkup } from './attributeInterpolationMarkup.js';
+import { enableNamespacedBindings } from './namespacedBindings.js';
+import { enableTextFilter } from './filters.js';
+
+let _enabledInterpolation = false;
+let _enabledAttributeInterpolation = false;
+let _enabledNamespacedBindings = false;
+let _enabledFilters = false;
+
+function enableFiltersGlobal(): void {
+  for (const key of Object.keys(bindingHandlers)) {
+    enableTextFilter(key);
+  }
+}
+
+export function ensureConfigured(): void {
+  if (options.interpolation && !_enabledInterpolation) {
+    _enabledInterpolation = true;
+    enableInterpolationMarkup();
+  }
+  if (options.attributeInterpolation && !_enabledAttributeInterpolation) {
+    _enabledAttributeInterpolation = true;
+    enableAttributeInterpolationMarkup();
+  }
+  if (options.namespacedBindings && !_enabledNamespacedBindings) {
+    _enabledNamespacedBindings = true;
+    enableNamespacedBindings();
+  }
+  if (options.filters && !_enabledFilters) {
+    _enabledFilters = true;
+    enableFiltersGlobal();
+  }
+}
+
+export function resetConfigured(): void {
+  _enabledInterpolation = false;
+  _enabledAttributeInterpolation = false;
+  _enabledNamespacedBindings = false;
+  _enabledFilters = false;
+  providerInstance.bindingCache = {};
+}
+
+export function enableAll(): void {
+  options.interpolation = true;
+  options.attributeInterpolation = true;
+  options.namespacedBindings = true;
+  options.filters = true;
+  ensureConfigured();
+}

package/src/controlFlowBindings.ts

@@ -1,206 +1,206 @@
-import { Computed } from './computed.js';
-import type { BindingHandler } from './bindingProvider.js';
-import type { AllBindingsAccessor } from './expressionRewriting.js';
-import type { CreateChildContextOptions, BindingContextOptions } from './bindingContext.js';
-import { bindingHandlers } from './bindingProvider.js';
-import { BindingContext } from './bindingContext.js';
-import { applyBindingsToDescendants } from './applyBindings.js';
-import { addDisposeCallback } from './domNodeDisposal.js';
-import { getDependenciesCount, getCurrentComputed } from './dependencyDetection.js';
-import { bindingEvent } from './bindingEvent.js';
-import { nativeTemplateEngine } from './templateEngine.js';
-import {
-  allowedVirtualElementBindings,
-  virtualChildNodes,
-  virtualEmptyNode,
-  virtualSetChildren,
-} from './virtualElements.js';
-import { unwrapObservable } from './utils.js';
-import { cloneNodes } from './utilsDom.js';
-
-// ---- if / ifnot / with ----
-
-function makeWithIfBinding(
-  bindingKey: string,
-  isWith?: boolean,
-  isNot?: boolean,
-): void {
-  const handler: BindingHandler = {
-    init(element, valueAccessor, allBindings, _viewModel, bindingContext) {
-      let didDisplayOnLastUpdate: boolean | undefined;
-      let savedNodes: Node[] | undefined;
-      let completeOnRender: boolean;
-      let needAsyncContext: boolean;
-      let renderOnEveryChange: boolean | undefined;
-
-      const contextOptions: Record<string, unknown> = {};
-
-      if (isWith) {
-        const as = (allBindings as AllBindingsAccessor).get('as') as string | undefined;
-        const noChildContext = (allBindings as AllBindingsAccessor).get('noChildContext') as boolean | undefined;
-        renderOnEveryChange = !(as && noChildContext);
-        contextOptions.as = as;
-        contextOptions.noChildContext = noChildContext;
-        contextOptions.exportDependencies = renderOnEveryChange;
-      }
-
-      completeOnRender = (allBindings as AllBindingsAccessor).get('completeOn') === 'render';
-      needAsyncContext = completeOnRender || (allBindings as AllBindingsAccessor).has(bindingEvent.descendantsComplete);
-
-      const computed = new Computed(() => {
-        const value = unwrapObservable(valueAccessor());
-        const shouldDisplay = !isNot !== !value;
-        const isInitial = !savedNodes;
-        let childContext: BindingContext | undefined;
-
-        if (!renderOnEveryChange && shouldDisplay === didDisplayOnLastUpdate) {
-          return;
-        }
-
-        let currentBindingContext = bindingContext!;
-        if (needAsyncContext) {
-          currentBindingContext = bindingEvent.startPossiblyAsyncContentBinding(element, currentBindingContext);
-        }
-
-        if (shouldDisplay) {
-          if (!isWith || renderOnEveryChange) {
-            const currentComputed = getCurrentComputed();
-            if (currentComputed) {
-              contextOptions.dataDependency = currentComputed as unknown as Computed<unknown>;
-            }
-          }
-
-          if (isWith) {
-            childContext = currentBindingContext.createChildContext(
-              typeof value === 'function' ? value : valueAccessor,
-              contextOptions as CreateChildContextOptions,
-            );
-          } else if (getDependenciesCount()) {
-            childContext = currentBindingContext.extend(null, contextOptions as BindingContextOptions);
-          } else {
-            childContext = currentBindingContext;
-          }
-        }
-
-        if (isInitial && getDependenciesCount()) {
-          savedNodes = cloneNodes(Array.from(virtualChildNodes(element)), true);
-        }
-
-        if (shouldDisplay) {
-          if (!isInitial) {
-            virtualSetChildren(element, cloneNodes(savedNodes!));
-          }
-          applyBindingsToDescendants(childContext!, element);
-        } else {
-          virtualEmptyNode(element);
-          if (!completeOnRender) {
-            bindingEvent.notify(element, bindingEvent.childrenComplete);
-          }
-        }
-
-        didDisplayOnLastUpdate = shouldDisplay;
-      });
-
-      addDisposeCallback(element, () => computed.dispose());
-
-      return { controlsDescendantBindings: true };
-    },
-  };
-
-  bindingHandlers[bindingKey] = handler;
-  allowedVirtualElementBindings[bindingKey] = true;
-}
-
-makeWithIfBinding('if');
-makeWithIfBinding('ifnot', false, true);
-makeWithIfBinding('with', true);
-
-// ---- let ----
-
-const letHandler: BindingHandler = {
-  init(element, valueAccessor, _allBindings, _viewModel, bindingContext) {
-    const innerContext = bindingContext!.extend(
-      valueAccessor as () => Record<string, unknown>,
-    );
-    applyBindingsToDescendants(innerContext, element);
-    return { controlsDescendantBindings: true };
-  },
-};
-
-bindingHandlers['let'] = letHandler;
-allowedVirtualElementBindings['let'] = true;
-
-// ---- using ----
-
-const usingHandler: BindingHandler = {
-  init(element, valueAccessor, allBindings, _viewModel, bindingContext) {
-    let options: { as?: string; noChildContext?: boolean } | undefined;
-    if ((allBindings as AllBindingsAccessor).has('as')) {
-      options = {
-        as: (allBindings as AllBindingsAccessor).get('as') as string,
-        noChildContext: (allBindings as AllBindingsAccessor).get('noChildContext') as boolean | undefined,
-      };
-    }
-    const innerContext = bindingContext!.createChildContext(valueAccessor, options);
-    applyBindingsToDescendants(innerContext, element);
-    return { controlsDescendantBindings: true };
-  },
-};
-
-bindingHandlers['using'] = usingHandler;
-allowedVirtualElementBindings['using'] = true;
-
-// ---- foreach ----
-
-function makeTemplateValueAccessor(valueAccessor: () => unknown): () => Record<string, unknown> {
-  return () => {
-    const modelValue = valueAccessor();
-    // Peek without setting dependency
-    const unwrappedValue = (modelValue && typeof modelValue === 'object' && 'peek' in (modelValue as Record<string, unknown>))
-      ? (modelValue as { peek(): unknown }).peek()
-      : modelValue;
-
-    if (!unwrappedValue || typeof (unwrappedValue as unknown[]).length === 'number') {
-      return { foreach: modelValue, templateEngine: nativeTemplateEngine };
-    }
-
-    unwrapObservable(modelValue);
-    const obj = unwrappedValue as Record<string, unknown>;
-    return {
-      foreach: obj.data,
-      as: obj.as,
-      noChildContext: obj.noChildContext,
-      includeDestroyed: obj.includeDestroyed,
-      afterAdd: obj.afterAdd,
-      beforeRemove: obj.beforeRemove,
-      afterRender: obj.afterRender,
-      beforeMove: obj.beforeMove,
-      afterMove: obj.afterMove,
-      templateEngine: nativeTemplateEngine,
-    };
-  };
-}
-
-const foreachHandler: BindingHandler = {
-  init(element, valueAccessor, allBindings, viewModel, bindingContext) {
-    return bindingHandlers['template'].init!(
-      element,
-      makeTemplateValueAccessor(valueAccessor),
-      allBindings,
-      viewModel,
-      bindingContext,
-    );
-  },
-  update(element, valueAccessor, allBindings, viewModel, bindingContext) {
-    return bindingHandlers['template'].update!(
-      element,
-      makeTemplateValueAccessor(valueAccessor),
-      allBindings,
-      viewModel,
-      bindingContext,
-    );
-  },
-};
-
-bindingHandlers['foreach'] = foreachHandler;
-allowedVirtualElementBindings['foreach'] = true;
+import { Computed } from './computed.js';
+import type { BindingHandler } from './bindingProvider.js';
+import type { AllBindingsAccessor } from './expressionRewriting.js';
+import type { CreateChildContextOptions, BindingContextOptions } from './bindingContext.js';
+import { bindingHandlers } from './bindingProvider.js';
+import { BindingContext } from './bindingContext.js';
+import { applyBindingsToDescendants } from './applyBindings.js';
+import { addDisposeCallback } from './domNodeDisposal.js';
+import { getDependenciesCount, getCurrentComputed } from './dependencyDetection.js';
+import { bindingEvent } from './bindingEvent.js';
+import { nativeTemplateEngine } from './templateEngine.js';
+import {
+  allowedVirtualElementBindings,
+  virtualChildNodes,
+  virtualEmptyNode,
+  virtualSetChildren,
+} from './virtualElements.js';
+import { unwrapObservable } from './utils.js';
+import { cloneNodes } from './utilsDom.js';
+
+// ---- if / ifnot / with ----
+
+function makeWithIfBinding(
+  bindingKey: string,
+  isWith?: boolean,
+  isNot?: boolean,
+): void {
+  const handler: BindingHandler = {
+    init(element, valueAccessor, allBindings, _viewModel, bindingContext) {
+      let didDisplayOnLastUpdate: boolean | undefined;
+      let savedNodes: Node[] | undefined;
+      let completeOnRender: boolean;
+      let needAsyncContext: boolean;
+      let renderOnEveryChange: boolean | undefined;
+
+      const contextOptions: Record<string, unknown> = {};
+
+      if (isWith) {
+        const as = (allBindings as AllBindingsAccessor).get('as') as string | undefined;
+        const noChildContext = (allBindings as AllBindingsAccessor).get('noChildContext') as boolean | undefined;
+        renderOnEveryChange = !(as && noChildContext);
+        contextOptions.as = as;
+        contextOptions.noChildContext = noChildContext;
+        contextOptions.exportDependencies = renderOnEveryChange;
+      }
+
+      completeOnRender = (allBindings as AllBindingsAccessor).get('completeOn') === 'render';
+      needAsyncContext = completeOnRender || (allBindings as AllBindingsAccessor).has(bindingEvent.descendantsComplete);
+
+      const computed = new Computed(() => {
+        const value = unwrapObservable(valueAccessor());
+        const shouldDisplay = !isNot !== !value;
+        const isInitial = !savedNodes;
+        let childContext: BindingContext | undefined;
+
+        if (!renderOnEveryChange && shouldDisplay === didDisplayOnLastUpdate) {
+          return;
+        }
+
+        let currentBindingContext = bindingContext!;
+        if (needAsyncContext) {
+          currentBindingContext = bindingEvent.startPossiblyAsyncContentBinding(element, currentBindingContext);
+        }
+
+        if (shouldDisplay) {
+          if (!isWith || renderOnEveryChange) {
+            const currentComputed = getCurrentComputed();
+            if (currentComputed) {
+              contextOptions.dataDependency = currentComputed as unknown as Computed<unknown>;
+            }
+          }
+
+          if (isWith) {
+            childContext = currentBindingContext.createChildContext(
+              typeof value === 'function' ? value : valueAccessor,
+              contextOptions as CreateChildContextOptions,
+            );
+          } else if (getDependenciesCount()) {
+            childContext = currentBindingContext.extend(null, contextOptions as BindingContextOptions);
+          } else {
+            childContext = currentBindingContext;
+          }
+        }
+
+        if (isInitial && getDependenciesCount()) {
+          savedNodes = cloneNodes(Array.from(virtualChildNodes(element)), true);
+        }
+
+        if (shouldDisplay) {
+          if (!isInitial) {
+            virtualSetChildren(element, cloneNodes(savedNodes!));
+          }
+          applyBindingsToDescendants(childContext!, element);
+        } else {
+          virtualEmptyNode(element);
+          if (!completeOnRender) {
+            bindingEvent.notify(element, bindingEvent.childrenComplete);
+          }
+        }
+
+        didDisplayOnLastUpdate = shouldDisplay;
+      });
+
+      addDisposeCallback(element, () => computed.dispose());
+
+      return { controlsDescendantBindings: true };
+    },
+  };
+
+  bindingHandlers[bindingKey] = handler;
+  allowedVirtualElementBindings[bindingKey] = true;
+}
+
+makeWithIfBinding('if');
+makeWithIfBinding('ifnot', false, true);
+makeWithIfBinding('with', true);
+
+// ---- let ----
+
+const letHandler: BindingHandler = {
+  init(element, valueAccessor, _allBindings, _viewModel, bindingContext) {
+    const innerContext = bindingContext!.extend(
+      valueAccessor as () => Record<string, unknown>,
+    );
+    applyBindingsToDescendants(innerContext, element);
+    return { controlsDescendantBindings: true };
+  },
+};
+
+bindingHandlers['let'] = letHandler;
+allowedVirtualElementBindings['let'] = true;
+
+// ---- using ----
+
+const usingHandler: BindingHandler = {
+  init(element, valueAccessor, allBindings, _viewModel, bindingContext) {
+    let options: { as?: string; noChildContext?: boolean } | undefined;
+    if ((allBindings as AllBindingsAccessor).has('as')) {
+      options = {
+        as: (allBindings as AllBindingsAccessor).get('as') as string,
+        noChildContext: (allBindings as AllBindingsAccessor).get('noChildContext') as boolean | undefined,
+      };
+    }
+    const innerContext = bindingContext!.createChildContext(valueAccessor, options);
+    applyBindingsToDescendants(innerContext, element);
+    return { controlsDescendantBindings: true };
+  },
+};
+
+bindingHandlers['using'] = usingHandler;
+allowedVirtualElementBindings['using'] = true;
+
+// ---- foreach ----
+
+function makeTemplateValueAccessor(valueAccessor: () => unknown): () => Record<string, unknown> {
+  return () => {
+    const modelValue = valueAccessor();
+    // Peek without setting dependency
+    const unwrappedValue = (modelValue && typeof modelValue === 'object' && 'peek' in (modelValue as Record<string, unknown>))
+      ? (modelValue as { peek(): unknown }).peek()
+      : modelValue;
+
+    if (!unwrappedValue || typeof (unwrappedValue as unknown[]).length === 'number') {
+      return { foreach: modelValue, templateEngine: nativeTemplateEngine };
+    }
+
+    unwrapObservable(modelValue);
+    const obj = unwrappedValue as Record<string, unknown>;
+    return {
+      foreach: obj.data,
+      as: obj.as,
+      noChildContext: obj.noChildContext,
+      includeDestroyed: obj.includeDestroyed,
+      afterAdd: obj.afterAdd,
+      beforeRemove: obj.beforeRemove,
+      afterRender: obj.afterRender,
+      beforeMove: obj.beforeMove,
+      afterMove: obj.afterMove,
+      templateEngine: nativeTemplateEngine,
+    };
+  };
+}
+
+const foreachHandler: BindingHandler = {
+  init(element, valueAccessor, allBindings, viewModel, bindingContext) {
+    return bindingHandlers['template'].init!(
+      element,
+      makeTemplateValueAccessor(valueAccessor),
+      allBindings,
+      viewModel,
+      bindingContext,
+    );
+  },
+  update(element, valueAccessor, allBindings, viewModel, bindingContext) {
+    return bindingHandlers['template'].update!(
+      element,
+      makeTemplateValueAccessor(valueAccessor),
+      allBindings,
+      viewModel,
+      bindingContext,
+    );
+  },
+};
+
+bindingHandlers['foreach'] = foreachHandler;
+allowedVirtualElementBindings['foreach'] = true;

package/src/core.ts

@@ -1,60 +1,60 @@
-export { options } from './options.js';
-
-export const version = '1.0.0';
-
-export { Subscribable, Subscription, isSubscribable, isReadableSubscribable, valuesArePrimitiveAndEqual } from './subscribable.js';
-export type { SubscriptionCallback, ReadableSubscribable } from './subscribable.js';
-
-export {
-  begin,
-  end,
-  registerDependency,
-  ignore,
-  getDependenciesCount,
-  getDependencies,
-  isInitial,
-  getCurrentComputed,
-} from './dependencyDetection.js';
-export type { TrackingFrame } from './dependencyDetection.js';
-
-export { Observable, isObservable } from './observable.js';
-
-export { ObservableArray, isObservableArray, DESTROY, isDestroyed } from './observableArray.js';
-
-export { compareArrays, findMovesInArrayComparison } from './compareArrays.js';
-export type { ArrayChange, CompareArraysOptions } from './compareArrays.js';
-
-export { Computed, PureComputed, isComputed, isPureComputed } from './computed.js';
-export type { ComputedOptions } from './computed.js';
-
-export { registerExtender, throttle, debounce } from './extenders.js';
-export type { ExtenderHandler, ExtenderMap, ExtenderOptions, RateLimitOptions } from './extenders.js';
-
-export { effect, observe } from './effects.js';
-export type { EffectHandle } from './effects.js';
-
-export { Event, EventSubscribable, EventSubscription, AggregateEvent, isEvent, isEventSubscribable, isAggregateEvent } from './event.js';
-export type { EventCallback, Constructor } from './event.js';
-
-export { DisposableGroup } from './disposable.js';
-export type { Disposable } from './disposable.js';
-
-export { reactive, reactiveArray, computed, getObservable, replaceObservable } from './decorators.js';
-
-export {
-  unwrapObservable, peekObservable, toJS, toJSON, when,
-  catchFunctionErrors,
-} from './utils.js';
-
-export { schedule, cancel, runEarly, resetForTesting } from './tasks.js';
-import * as tasks from './tasks.js';
-export { tasks };
-
-import { Observable } from './observable.js';
-import { Computed } from './computed.js';
-
-export function isWritableObservable(value: unknown): value is Observable<unknown> | Computed<unknown> {
-  if (value instanceof Observable) return true;
-  if (value instanceof Computed) return value.hasWriteFunction;
-  return false;
-}
+export { options } from './options.js';
+
+export const version = '1.0.0';
+
+export { Subscribable, Subscription, isSubscribable, isReadableSubscribable, valuesArePrimitiveAndEqual } from './subscribable.js';
+export type { SubscriptionCallback, ReadableSubscribable } from './subscribable.js';
+
+export {
+  begin,
+  end,
+  registerDependency,
+  ignore,
+  getDependenciesCount,
+  getDependencies,
+  isInitial,
+  getCurrentComputed,
+} from './dependencyDetection.js';
+export type { TrackingFrame } from './dependencyDetection.js';
+
+export { Observable, isObservable } from './observable.js';
+
+export { ObservableArray, isObservableArray, DESTROY, isDestroyed } from './observableArray.js';
+
+export { compareArrays, findMovesInArrayComparison } from './compareArrays.js';
+export type { ArrayChange, CompareArraysOptions } from './compareArrays.js';
+
+export { Computed, PureComputed, isComputed, isPureComputed } from './computed.js';
+export type { ComputedOptions } from './computed.js';
+
+export { registerExtender, throttle, debounce } from './extenders.js';
+export type { ExtenderHandler, ExtenderMap, ExtenderOptions, RateLimitOptions } from './extenders.js';
+
+export { effect, observe } from './effects.js';
+export type { EffectHandle } from './effects.js';
+
+export { Event, EventSubscribable, EventSubscription, AggregateEvent, isEvent, isEventSubscribable, isAggregateEvent } from './event.js';
+export type { EventCallback, Constructor } from './event.js';
+
+export { DisposableGroup } from './disposable.js';
+export type { Disposable } from './disposable.js';
+
+export { reactive, reactiveArray, computed, getObservable, replaceObservable } from './decorators.js';
+
+export {
+  unwrapObservable, peekObservable, toJS, toJSON, when,
+  catchFunctionErrors,
+} from './utils.js';
+
+export { schedule, cancel, runEarly, resetForTesting } from './tasks.js';
+import * as tasks from './tasks.js';
+export { tasks };
+
+import { Observable } from './observable.js';
+import { Computed } from './computed.js';
+
+export function isWritableObservable(value: unknown): value is Observable<unknown> | Computed<unknown> {
+  if (value instanceof Observable) return true;
+  if (value instanceof Computed) return value.hasWriteFunction;
+  return false;
+}