tungsten 0.4.13 → 0.4.14

package/dist/signals/tracking.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Dependency tracking for signals components.
+ *
+ * Dependencies are keyed by (object identity, key) in a side table rather than by path, so a
+ * consumer is connected to whatever object it actually read, wherever that object sits in a
+ * state tree -- a child reading `props.item.name` subscribes to (item, 'name') directly.
+ * The state proxies call track() from their get traps and notify() from their write paths;
+ * an effect collects its dependencies while it runs and drops them all before each re-run.
+ *
+ * Only synchronous reads are tracked: the active effect is restored as soon as fn() returns,
+ * so reads after an `await` inside an async content() are not seen.
+ *
+ * No imports here on purpose -- the proxy handlers depend on this, so it must stay a leaf.
+ */
+export type Effect = {
+    deps: Set<Set<Effect>>;
+    trigger: () => void;
+};
+export declare const ITERATE: unique symbol;
+export declare function createEffect(trigger: () => void): Effect;
+export declare function isTracking(): boolean;
+/** called by the proxies on every read; a no-op unless an effect is running */
+export declare function track(target: object, key: unknown): void;
+/** wake every effect subscribed to any of the given keys, each at most once */
+export declare function notify(target: object, ...keys: unknown[]): void;
+/** wake every effect subscribed to anything on the target; for bulk mutations like splice */
+export declare function notifyAll(target: object): void;
+/** run fn with reads subscribing the effect; previous deps are dropped so they are re-collected */
+export declare function runEffect<T>(effect: Effect, fn: () => T): T;
+/** run fn without subscribing the current effect to anything it reads */
+export declare function untracked<T>(fn: () => T): T;
+export declare function disposeEffect(effect: Effect): void;
+//# sourceMappingURL=tracking.d.ts.map

package/dist/signals/tracking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracking.d.ts","sourceRoot":"","sources":["../../src/signals/tracking.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,MAAM,GAAG;IAEjB,IAAI,EAAE,GAAG,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;IACtB,OAAO,EAAE,MAAM,IAAI,CAAA;CACtB,CAAA;AAID,eAAO,MAAM,OAAO,eAAoB,CAAA;AAMxC,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,IAAI,GAAG,MAAM,CAExD;AAED,wBAAgB,UAAU,IAAI,OAAO,CAEpC;AAED,+EAA+E;AAC/E,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,GAAG,IAAI,CAUxD;AAED,+EAA+E;AAC/E,wBAAgB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,IAAI,CAS/D;AAED,6FAA6F;AAC7F,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAM9C;AAOD,mGAAmG;AACnG,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAS3D;AAED,yEAAyE;AACzE,wBAAgB,SAAS,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAQ3C;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAElD"}

package/dist/signals/tracking.js

@@ -0,0 +1,87 @@
+/**
+ * Dependency tracking for signals components.
+ *
+ * Dependencies are keyed by (object identity, key) in a side table rather than by path, so a
+ * consumer is connected to whatever object it actually read, wherever that object sits in a
+ * state tree -- a child reading `props.item.name` subscribes to (item, 'name') directly.
+ * The state proxies call track() from their get traps and notify() from their write paths;
+ * an effect collects its dependencies while it runs and drops them all before each re-run.
+ *
+ * Only synchronous reads are tracked: the active effect is restored as soon as fn() returns,
+ * so reads after an `await` inside an async content() are not seen.
+ *
+ * No imports here on purpose -- the proxy handlers depend on this, so it must stay a leaf.
+ */
+// pseudo-key for reads that depend on the whole collection: Object.keys, for..in, Map/Set
+// iteration and size. Array iteration reads 'length' and the indexes, so needs no pseudo-key.
+export const ITERATE = Symbol('iterate');
+const subscribers = new WeakMap();
+let active = null;
+export function createEffect(trigger) {
+  return {
+    deps: new Set(),
+    trigger
+  };
+}
+export function isTracking() {
+  return active !== null;
+}
+/** called by the proxies on every read; a no-op unless an effect is running */
+export function track(target, key) {
+  if (active === null) return;
+  let keys = subscribers.get(target);
+  if (keys === undefined) subscribers.set(target, keys = new Map());
+  let subs = keys.get(key);
+  if (subs === undefined) keys.set(key, subs = new Set());
+  if (!subs.has(active)) {
+    subs.add(active);
+    active.deps.add(subs);
+  }
+}
+/** wake every effect subscribed to any of the given keys, each at most once */
+export function notify(target, ...keys) {
+  const map = subscribers.get(target);
+  if (map === undefined) return;
+  const fired = new Set();
+  for (const key of keys) {
+    const subs = map.get(key);
+    if (subs !== undefined) for (const effect of subs) fired.add(effect);
+  }
+  for (const effect of fired) effect.trigger();
+}
+/** wake every effect subscribed to anything on the target; for bulk mutations like splice */
+export function notifyAll(target) {
+  const map = subscribers.get(target);
+  if (map === undefined) return;
+  const fired = new Set();
+  for (const subs of map.values()) for (const effect of subs) fired.add(effect);
+  for (const effect of fired) effect.trigger();
+}
+function clearDeps(effect) {
+  for (const subs of effect.deps) subs.delete(effect);
+  effect.deps.clear();
+}
+/** run fn with reads subscribing the effect; previous deps are dropped so they are re-collected */
+export function runEffect(effect, fn) {
+  clearDeps(effect);
+  const previous = active;
+  active = effect;
+  try {
+    return fn();
+  } finally {
+    active = previous;
+  }
+}
+/** run fn without subscribing the current effect to anything it reads */
+export function untracked(fn) {
+  const previous = active;
+  active = null;
+  try {
+    return fn();
+  } finally {
+    active = previous;
+  }
+}
+export function disposeEffect(effect) {
+  clearDeps(effect);
+}

package/dist/warnOnFrameworkChange.js

@@ -8,7 +8,7 @@ import { cliWarn } from './cliOutput.js';
 // full process restart - this just tells the developer that's needed, rather than attempting it.
 //
 // Watches a single marker file (dist/.build-complete) rather than all of dist - tungsten's own
-// build scripts touch it as their last step (see scripts/writeBuildMarker.mjs), so one file
+// build scripts touch it as their last step (see scripts/writeBuildMarker.ts), so one file
 // covers every file a build could have changed without chokidar scanning the whole tree. Watch
 // mode (build-babel --watch) does not yet write it on each cycle, only the one-shot builds do.
 export function warnOnFrameworkChange() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tungsten",
-  "version": "0.4.13",
+  "version": "0.4.14",
   "description": "",
   "type": "module",
   "bin": {
@@ -121,16 +121,16 @@
     "build": "run-s -c clean build-prep build-watch",
     "clean": "rimraf intermed dist",
     "build-once": "rimraf intermed dist && pnpm build-ts-once && pnpm build-babel-once && pnpm build-component-styles",
-    "build-component-styles": "node scripts/buildComponentStyles.mjs",
-    "build-vendor": "node scripts/bundleVendor.mjs",
-    "build-once-nd": "rimraf intermed dist.building && pnpm build-ts-once && pnpm build-babel-staged && node scripts/syncDist.mjs && node scripts/writeBuildMarker.mjs",
+    "build-component-styles": "node scripts/buildComponentStyles.ts",
+    "build-vendor": "node scripts/bundleVendor.ts",
+    "build-once-nd": "rimraf intermed dist.building && pnpm build-ts-once && pnpm build-babel-staged && node scripts/syncDist.ts && node scripts/writeBuildMarker.ts",
     "build-quick": "pnpm build-watch",
     "build-prep": "pnpm build-ts-once",
     "build-watch": "run-p build-ts build-babel",
     "build-ts": "tsc --watch",
     "build-ts-once": "tsc",
-    "build-babel": "node scripts/watchBabelAndMark.mjs",
-    "build-babel-once": "babel intermed --out-dir dist --ignore \"**/*.cjs\" --copy-files --config-file ./babel.framework.config.js && node scripts/writeBuildMarker.mjs",
+    "build-babel": "node scripts/watchBabelAndMark.ts",
+    "build-babel-once": "babel intermed --out-dir dist --ignore \"**/*.cjs\" --copy-files --config-file ./babel.framework.config.js && node scripts/writeBuildMarker.ts",
     "build-babel-staged": "babel intermed --out-dir dist.building --ignore \"**/*.cjs\" --copy-files --config-file ./babel.framework.config.js",
     "test": "sxy-test-runner",
     "test-once": "sxy-test-runner once",