@thomas-siegfried/tapout 0.0.1 → 0.0.2

package/src/dependencyDetection.ts

@@ -1,76 +1,76 @@
-import { type Subscribable, isSubscribable } from './subscribable.js';
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- variance: detection is type-agnostic
-type AnySubscribable = Subscribable<any>;
-
-export interface TrackingFrame {
-  callback: (subscribable: AnySubscribable, id: number) => void;
-  computed?: {
-    getDependenciesCount(): number;
-    getDependencies(): AnySubscribable[];
-  };
-  isInitial?: boolean;
-}
-
-let lastId = 0;
-const outerFrames: Array<TrackingFrame | undefined> = [];
-let currentFrame: TrackingFrame | undefined;
-
-export function getId(): number {
-  return ++lastId;
-}
-
-export function begin(frame?: TrackingFrame): void {
-  outerFrames.push(currentFrame);
-  currentFrame = frame;
-}
-
-export function end(): void {
-  currentFrame = outerFrames.pop();
-}
-
-export function registerDependency(subscribable: AnySubscribable): void {
-  if (currentFrame) {
-    if (!isSubscribable(subscribable)) {
-      throw new Error('Only subscribable things can act as dependencies');
-    }
-    currentFrame.callback(
-      subscribable,
-      subscribable._id || (subscribable._id = getId()),
-    );
-  }
-}
-
-export function ignore<R>(callback: () => R): R {
-  try {
-    begin();
-    return callback();
-  } finally {
-    end();
-  }
-}
-
-export function getDependenciesCount(): number | undefined {
-  if (currentFrame?.computed) {
-    return currentFrame.computed.getDependenciesCount();
-  }
-  return undefined;
-}
-
-export function getDependencies(): AnySubscribable[] | undefined {
-  if (currentFrame?.computed) {
-    return currentFrame.computed.getDependencies();
-  }
-  return undefined;
-}
-
-export function isInitial(): boolean | undefined {
-  if (currentFrame) {
-    return currentFrame.isInitial;
-  }
-  return undefined;
-}
-
-export function getCurrentComputed(): TrackingFrame['computed'] | undefined {
-  return currentFrame?.computed;
-}
+import { type Subscribable, isSubscribable } from './subscribable.js';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- variance: detection is type-agnostic
+type AnySubscribable = Subscribable<any>;
+
+export interface TrackingFrame {
+  callback: (subscribable: AnySubscribable, id: number) => void;
+  computed?: {
+    getDependenciesCount(): number;
+    getDependencies(): AnySubscribable[];
+  };
+  isInitial?: boolean;
+}
+
+let lastId = 0;
+const outerFrames: Array<TrackingFrame | undefined> = [];
+let currentFrame: TrackingFrame | undefined;
+
+export function getId(): number {
+  return ++lastId;
+}
+
+export function begin(frame?: TrackingFrame): void {
+  outerFrames.push(currentFrame);
+  currentFrame = frame;
+}
+
+export function end(): void {
+  currentFrame = outerFrames.pop();
+}
+
+export function registerDependency(subscribable: AnySubscribable): void {
+  if (currentFrame) {
+    if (!isSubscribable(subscribable)) {
+      throw new Error('Only subscribable things can act as dependencies');
+    }
+    currentFrame.callback(
+      subscribable,
+      subscribable._id || (subscribable._id = getId()),
+    );
+  }
+}
+
+export function ignore<R>(callback: () => R): R {
+  try {
+    begin();
+    return callback();
+  } finally {
+    end();
+  }
+}
+
+export function getDependenciesCount(): number | undefined {
+  if (currentFrame?.computed) {
+    return currentFrame.computed.getDependenciesCount();
+  }
+  return undefined;
+}
+
+export function getDependencies(): AnySubscribable[] | undefined {
+  if (currentFrame?.computed) {
+    return currentFrame.computed.getDependencies();
+  }
+  return undefined;
+}
+
+export function isInitial(): boolean | undefined {
+  if (currentFrame) {
+    return currentFrame.isInitial;
+  }
+  return undefined;
+}
+
+export function getCurrentComputed(): TrackingFrame['computed'] | undefined {
+  return currentFrame?.computed;
+}

package/src/disposable.ts

@@ -1,36 +1,36 @@
-export interface Disposable {
-  dispose(): void;
-}
-
-export class DisposableGroup implements Disposable {
-  private _disposables: Disposable[] = [];
-  private _isDisposed = false;
-
-  add<T extends Disposable>(disposable: T): T {
-    if (this._isDisposed) {
-      disposable.dispose();
-      return disposable;
-    }
-    this._disposables.push(disposable);
-    return disposable;
-  }
-
-  dispose(): void {
-    if (!this._isDisposed) {
-      this._isDisposed = true;
-      const items = this._disposables;
-      this._disposables = [];
-      for (let i = 0; i < items.length; i++) {
-        items[i].dispose();
-      }
-    }
-  }
-
-  get isDisposed(): boolean {
-    return this._isDisposed;
-  }
-
-  get count(): number {
-    return this._disposables.length;
-  }
-}
+export interface Disposable {
+  dispose(): void;
+}
+
+export class DisposableGroup implements Disposable {
+  private _disposables: Disposable[] = [];
+  private _isDisposed = false;
+
+  add<T extends Disposable>(disposable: T): T {
+    if (this._isDisposed) {
+      disposable.dispose();
+      return disposable;
+    }
+    this._disposables.push(disposable);
+    return disposable;
+  }
+
+  dispose(): void {
+    if (!this._isDisposed) {
+      this._isDisposed = true;
+      const items = this._disposables;
+      this._disposables = [];
+      for (let i = 0; i < items.length; i++) {
+        items[i].dispose();
+      }
+    }
+  }
+
+  get isDisposed(): boolean {
+    return this._isDisposed;
+  }
+
+  get count(): number {
+    return this._disposables.length;
+  }
+}

package/src/domData.ts

@@ -1,42 +1,42 @@
-const dataStore = new WeakMap<object, Map<string, unknown>>();
-let nextId = 0;
-
-export function domDataGet(node: object, key: string): unknown {
-  return dataStore.get(node)?.get(key);
-}
-
-export function domDataSet(node: object, key: string, value: unknown): void {
-  if (value === undefined) {
-    const data = dataStore.get(node);
-    if (data) {
-      data.delete(key);
-      if (data.size === 0) dataStore.delete(node);
-    }
-    return;
-  }
-  let data = dataStore.get(node);
-  if (!data) {
-    data = new Map();
-    dataStore.set(node, data);
-  }
-  data.set(key, value);
-}
-
-export function domDataGetOrSet(node: object, key: string, value: unknown): unknown {
-  let data = dataStore.get(node);
-  if (!data) {
-    data = new Map();
-    dataStore.set(node, data);
-  }
-  if (data.has(key)) return data.get(key);
-  data.set(key, value);
-  return value;
-}
-
-export function domDataClear(node: object): boolean {
-  return dataStore.delete(node);
-}
-
-export function domDataNextKey(): string {
-  return `__tapout_${nextId++}`;
-}
+const dataStore = new WeakMap<object, Map<string, unknown>>();
+let nextId = 0;
+
+export function domDataGet(node: object, key: string): unknown {
+  return dataStore.get(node)?.get(key);
+}
+
+export function domDataSet(node: object, key: string, value: unknown): void {
+  if (value === undefined) {
+    const data = dataStore.get(node);
+    if (data) {
+      data.delete(key);
+      if (data.size === 0) dataStore.delete(node);
+    }
+    return;
+  }
+  let data = dataStore.get(node);
+  if (!data) {
+    data = new Map();
+    dataStore.set(node, data);
+  }
+  data.set(key, value);
+}
+
+export function domDataGetOrSet(node: object, key: string, value: unknown): unknown {
+  let data = dataStore.get(node);
+  if (!data) {
+    data = new Map();
+    dataStore.set(node, data);
+  }
+  if (data.has(key)) return data.get(key);
+  data.set(key, value);
+  return value;
+}
+
+export function domDataClear(node: object): boolean {
+  return dataStore.delete(node);
+}
+
+export function domDataNextKey(): string {
+  return `__tapout_${nextId++}`;
+}

package/src/domNodeDisposal.ts

@@ -1,94 +1,94 @@
-import { domDataGet, domDataSet, domDataClear, domDataNextKey } from './domData.js';
-import { ignore } from './dependencyDetection.js';
-
-type DisposeCallback = (node: Node) => void;
-
-const disposeCallbacksKey = domDataNextKey();
-
-const CLEANABLE: Record<number, boolean> = { 1: true, 8: true, 9: true };
-const CLEANABLE_WITH_DESCENDANTS: Record<number, boolean> = { 1: true, 9: true };
-
-function getCallbacks(node: Node, create: true): DisposeCallback[];
-function getCallbacks(node: Node, create: false): DisposeCallback[] | undefined;
-function getCallbacks(node: Node, create: boolean): DisposeCallback[] | undefined {
-  let callbacks = domDataGet(node, disposeCallbacksKey) as DisposeCallback[] | undefined;
-  if (!callbacks && create) {
-    callbacks = [];
-    domDataSet(node, disposeCallbacksKey, callbacks);
-  }
-  return callbacks;
-}
-
-function destroyCallbacks(node: Node): void {
-  domDataSet(node, disposeCallbacksKey, undefined);
-}
-
-function cleanSingleNode(node: Node): void {
-  const callbacks = getCallbacks(node, false);
-  if (callbacks) {
-    const snapshot = callbacks.slice(0);
-    for (let i = 0; i < snapshot.length; i++) {
-      snapshot[i](node);
-    }
-  }
-
-  domDataClear(node);
-
-  if (CLEANABLE_WITH_DESCENDANTS[node.nodeType]) {
-    cleanNodesInList(node.childNodes, true);
-  }
-}
-
-function cleanNodesInList(nodeList: ArrayLike<Node>, onlyComments?: boolean): void {
-  const cleaned: Node[] = [];
-  let lastCleaned: Node;
-  for (let i = 0; i < nodeList.length; i++) {
-    if (!onlyComments || nodeList[i].nodeType === 8) {
-      cleanSingleNode(cleaned[cleaned.length] = lastCleaned = nodeList[i]);
-      if (nodeList[i] !== lastCleaned) {
-        while (i-- && cleaned.indexOf(nodeList[i]) === -1) { /* adjust index */ }
-      }
-    }
-  }
-}
-
-export function addDisposeCallback(node: Node, callback: DisposeCallback): void {
-  if (typeof callback !== 'function') {
-    throw new Error('Callback must be a function');
-  }
-  getCallbacks(node, true).push(callback);
-}
-
-export function removeDisposeCallback(node: Node, callback: DisposeCallback): void {
-  const callbacks = getCallbacks(node, false);
-  if (callbacks) {
-    const index = callbacks.indexOf(callback);
-    if (index >= 0) {
-      callbacks.splice(index, 1);
-      if (callbacks.length === 0) {
-        destroyCallbacks(node);
-      }
-    }
-  }
-}
-
-export function cleanNode(node: Node): Node {
-  ignore(() => {
-    if (CLEANABLE[node.nodeType]) {
-      cleanSingleNode(node);
-
-      if (CLEANABLE_WITH_DESCENDANTS[node.nodeType]) {
-        const descendants = (node as Element).getElementsByTagName('*');
-        cleanNodesInList(descendants);
-      }
-    }
-  });
-  return node;
-}
-
-export function removeNode(node: Node): void {
-  cleanNode(node);
-  if (node.parentNode) {
-    node.parentNode.removeChild(node);
-  }
-}
+import { domDataGet, domDataSet, domDataClear, domDataNextKey } from './domData.js';
+import { ignore } from './dependencyDetection.js';
+
+type DisposeCallback = (node: Node) => void;
+
+const disposeCallbacksKey = domDataNextKey();
+
+const CLEANABLE: Record<number, boolean> = { 1: true, 8: true, 9: true };
+const CLEANABLE_WITH_DESCENDANTS: Record<number, boolean> = { 1: true, 9: true };
+
+function getCallbacks(node: Node, create: true): DisposeCallback[];
+function getCallbacks(node: Node, create: false): DisposeCallback[] | undefined;
+function getCallbacks(node: Node, create: boolean): DisposeCallback[] | undefined {
+  let callbacks = domDataGet(node, disposeCallbacksKey) as DisposeCallback[] | undefined;
+  if (!callbacks && create) {
+    callbacks = [];
+    domDataSet(node, disposeCallbacksKey, callbacks);
+  }
+  return callbacks;
+}
+
+function destroyCallbacks(node: Node): void {
+  domDataSet(node, disposeCallbacksKey, undefined);
+}
+
+function cleanSingleNode(node: Node): void {
+  const callbacks = getCallbacks(node, false);
+  if (callbacks) {
+    const snapshot = callbacks.slice(0);
+    for (let i = 0; i < snapshot.length; i++) {
+      snapshot[i](node);
+    }
+  }
+
+  domDataClear(node);
+
+  if (CLEANABLE_WITH_DESCENDANTS[node.nodeType]) {
+    cleanNodesInList(node.childNodes, true);
+  }
+}
+
+function cleanNodesInList(nodeList: ArrayLike<Node>, onlyComments?: boolean): void {
+  const cleaned: Node[] = [];
+  let lastCleaned: Node;
+  for (let i = 0; i < nodeList.length; i++) {
+    if (!onlyComments || nodeList[i].nodeType === 8) {
+      cleanSingleNode(cleaned[cleaned.length] = lastCleaned = nodeList[i]);
+      if (nodeList[i] !== lastCleaned) {
+        while (i-- && cleaned.indexOf(nodeList[i]) === -1) { /* adjust index */ }
+      }
+    }
+  }
+}
+
+export function addDisposeCallback(node: Node, callback: DisposeCallback): void {
+  if (typeof callback !== 'function') {
+    throw new Error('Callback must be a function');
+  }
+  getCallbacks(node, true).push(callback);
+}
+
+export function removeDisposeCallback(node: Node, callback: DisposeCallback): void {
+  const callbacks = getCallbacks(node, false);
+  if (callbacks) {
+    const index = callbacks.indexOf(callback);
+    if (index >= 0) {
+      callbacks.splice(index, 1);
+      if (callbacks.length === 0) {
+        destroyCallbacks(node);
+      }
+    }
+  }
+}
+
+export function cleanNode(node: Node): Node {
+  ignore(() => {
+    if (CLEANABLE[node.nodeType]) {
+      cleanSingleNode(node);
+
+      if (CLEANABLE_WITH_DESCENDANTS[node.nodeType]) {
+        const descendants = (node as Element).getElementsByTagName('*');
+        cleanNodesInList(descendants);
+      }
+    }
+  });
+  return node;
+}
+
+export function removeNode(node: Node): void {
+  cleanNode(node);
+  if (node.parentNode) {
+    node.parentNode.removeChild(node);
+  }
+}

package/src/effects.ts

@@ -1,29 +1,29 @@
-import { PureComputed } from './computed.js';
-
-export interface EffectHandle {
-  dispose(): void;
-}
-
-/**
- * Track reactive dependencies in `fn` and call `act` whenever they change.
- * Returns a handle to stop the effect.
- */
-export function observe<T>(fn: () => T, act: (val: T) => void): EffectHandle {
-  const computed = new PureComputed(fn);
-  computed.extend({ notify: 'always' });
-  const subscription = computed.subscribe(act);
-  return {
-    dispose() {
-      subscription.dispose();
-      computed.dispose();
-    },
-  };
-}
-
-/**
- * Same as `observe`, but also runs `act` immediately with the current value.
- */
-export function effect<T>(fn: () => T, act: (val: T) => void): EffectHandle {
-  act(fn());
-  return observe(fn, act);
-}
+import { PureComputed } from './computed.js';
+
+export interface EffectHandle {
+  dispose(): void;
+}
+
+/**
+ * Track reactive dependencies in `fn` and call `act` whenever they change.
+ * Returns a handle to stop the effect.
+ */
+export function observe<T>(fn: () => T, act: (val: T) => void): EffectHandle {
+  const computed = new PureComputed(fn);
+  computed.extend({ notify: 'always' });
+  const subscription = computed.subscribe(act);
+  return {
+    dispose() {
+      subscription.dispose();
+      computed.dispose();
+    },
+  };
+}
+
+/**
+ * Same as `observe`, but also runs `act` immediately with the current value.
+ */
+export function effect<T>(fn: () => T, act: (val: T) => void): EffectHandle {
+  act(fn());
+  return observe(fn, act);
+}