@yuzhouu/canvas-kit 0.1.2

package/_vendor/signals/core.ts

@@ -0,0 +1,130 @@
+import { Child, Signal } from "./types";
+
+/** Global epoch counter — increments on every atom change */
+let globalEpoch = 0;
+
+export function getGlobalEpoch(): number {
+  return globalEpoch;
+}
+
+export function advanceGlobalEpoch(): number {
+  return ++globalEpoch;
+}
+
+// --- Transaction ---
+
+interface Transaction {
+  initialAtomValues: Map<_Atom<any>, any>;
+}
+
+let currentTransaction: Transaction | null = null;
+
+export function getCurrentTransaction(): Transaction | null {
+  return currentTransaction;
+}
+
+export function transact(fn: () => void): void {
+  if (currentTransaction) {
+    // Nested transaction — just run inside the existing one
+    fn();
+    return;
+  }
+
+  const txn: Transaction = { initialAtomValues: new Map() };
+  currentTransaction = txn;
+  try {
+    fn();
+    // Commit: flush all effects
+    flushChanges(txn.initialAtomValues.keys());
+  } catch (e) {
+    // Abort: rollback
+    for (const [a, value] of txn.initialAtomValues) {
+      a.__unsafe__setWithoutNotify(value);
+    }
+    throw e;
+  } finally {
+    currentTransaction = null;
+  }
+}
+
+export function noteInitialValue(
+  atom: _Atom<any>,
+  previousValue: any,
+): void {
+  if (
+    currentTransaction &&
+    !currentTransaction.initialAtomValues.has(atom)
+  ) {
+    currentTransaction.initialAtomValues.set(atom, previousValue);
+  }
+}
+
+// --- Dependency capture ---
+
+interface CaptureFrame {
+  child: Child;
+  parentSet: Set<Signal<any>>;
+  below: CaptureFrame | null;
+}
+
+let captureStack: CaptureFrame | null = null;
+
+export function startCapture(child: Child): void {
+  captureStack = { child, parentSet: new Set(), below: captureStack };
+}
+
+export function stopCapture(): Set<Signal<any>> {
+  if (!captureStack) {
+    throw new Error(
+      "Cannot stop dependency capture because no capture is active",
+    );
+  }
+  const frame = captureStack;
+  captureStack = frame.below;
+  return frame.parentSet;
+}
+
+export function maybeCaptureParent(parent: Signal<any>): void {
+  if (!captureStack) return;
+  captureStack.parentSet.add(parent);
+  parent.children.add(captureStack.child);
+}
+
+// --- Change propagation ---
+
+function flushChanges(changedAtoms: Iterable<_Atom<any>>): void {
+  const effects = new Set<Child>();
+  const visited = new Set<Child>();
+
+  function traverse(children: Set<Child>) {
+    for (const child of children) {
+      if (visited.has(child)) continue;
+      visited.add(child);
+      if (child.type === "effect") {
+        effects.add(child);
+      } else if (child.type === "computed") {
+        const source = child.source;
+        if (source) traverse(source.children);
+      }
+    }
+  }
+
+  for (const atom of changedAtoms) {
+    traverse(atom.children);
+  }
+
+  for (const effect of effects) {
+    effect.notify();
+  }
+}
+
+export function atomDidChange(atom: _Atom<any>): void {
+  if (!currentTransaction) {
+    flushChanges([atom]);
+  }
+}
+
+// Forward reference types — implemented in their own files
+interface _Atom<T> extends Signal<T> {
+  __unsafe__setWithoutNotify(value: T): void;
+}

package/_vendor/signals/effect.ts

@@ -0,0 +1,117 @@
+import { Child, Signal } from "./types";
+import { getGlobalEpoch, startCapture, stopCapture } from "./core";
+
+export interface EffectSchedulerOptions {
+  scheduleEffect?: (execute: () => void) => void;
+}
+
+export class EffectScheduler {
+  type = "effect" as const;
+  private parents: Signal<any>[] = [];
+  private parentEpochs: number[] = [];
+  private lastReactedEpoch = -1;
+  private isActive = false;
+  private scheduleEffect?: (execute: () => void) => void;
+
+  constructor(
+    public readonly name: string,
+    private fn: () => void,
+    opts?: EffectSchedulerOptions,
+  ) {
+    this.scheduleEffect = opts?.scheduleEffect;
+  }
+
+  private selfAsChild: Child = {
+    type: "effect",
+    notify: () => this.maybeSchedule(),
+  };
+
+  attach(): void {
+    this.isActive = true;
+    this.execute();
+  }
+
+  detach(): void {
+    this.isActive = false;
+    // Remove from all parents
+    for (const parent of this.parents) {
+      parent.children.delete(this.selfAsChild);
+    }
+    this.parents = [];
+    this.parentEpochs = [];
+  }
+
+  maybeSchedule(): void {
+    if (!this.isActive) return;
+    if (this.lastReactedEpoch === getGlobalEpoch()) return;
+
+    if (!this.haveParentsChanged()) {
+      this.lastReactedEpoch = getGlobalEpoch();
+      return;
+    }
+
+    if (this.scheduleEffect) {
+      this.scheduleEffect(() => this.execute());
+    } else {
+      this.execute();
+    }
+  }
+
+  execute(): void {
+    if (!this.isActive) return;
+
+    // Remove from old parents
+    for (const parent of this.parents) {
+      parent.children.delete(this.selfAsChild);
+    }
+
+    startCapture(this.selfAsChild);
+    try {
+      this.fn();
+    } finally {
+      const newParentSet = stopCapture();
+      this.parents = [...newParentSet];
+      this.parentEpochs = this.parents.map((p) => p.lastChangedEpoch);
+      for (const parent of this.parents) {
+        parent.children.add(this.selfAsChild);
+      }
+      this.lastReactedEpoch = getGlobalEpoch();
+    }
+  }
+
+  private haveParentsChanged(): boolean {
+    for (let i = 0; i < this.parents.length; i++) {
+      const parent = this.parents[i];
+      parent.__unsafe__getWithoutCapture();
+      if (parent.lastChangedEpoch !== this.parentEpochs[i]) {
+        return true;
+      }
+    }
+    return false;
+  }
+}
+
+/**
+ * Create a reactive effect that re-runs whenever its dependencies change.
+ * Returns a cleanup function to stop the effect.
+ */
+export function effect(
+  name: string,
+  fn: () => void,
+  opts?: EffectSchedulerOptions,
+): () => void {
+  const scheduler = new EffectScheduler(name, fn, opts);
+  scheduler.attach();
+  return () => scheduler.detach();
+}
+
+/**
+ * Alias: react() — same as effect()
+ */
+export function react(
+  name: string,
+  fn: () => void,
+  opts?: EffectSchedulerOptions,
+): () => void {
+  return effect(name, fn, opts);
+}

package/_vendor/signals/index.ts

@@ -0,0 +1,9 @@
+export { atom, isAtom } from "./atom";
+export type { Atom } from "./atom";
+export { computed, isComputed, UNINITIALIZED } from "./computed";
+export type { Computed } from "./computed";
+export { effect, react, EffectScheduler } from "./effect";
+export type { EffectSchedulerOptions } from "./effect";
+export { transact, getGlobalEpoch } from "./core";
+export { RESET_VALUE } from "./types";
+export type { Signal, Child } from "./types";

package/_vendor/signals/types.ts

@@ -0,0 +1,17 @@
+/** A reactive signal that holds subscribers */
+export interface Signal<T> {
+  readonly name: string;
+  get(): T;
+  __unsafe__getWithoutCapture(): T;
+  lastChangedEpoch: number;
+  children: Set<Child>;
+}
+
+export interface Child {
+  type: "computed" | "effect";
+  notify(): void;
+  source?: Signal<any>;
+}
+
+export const RESET_VALUE: unique symbol = Symbol("RESET_VALUE");
+export type RESET_VALUE = typeof RESET_VALUE;

package/_vendor/store/Store.ts

@@ -0,0 +1,171 @@
+import { atom, type Atom } from "@land/signals";
+import {
+  createEmptyRecordsDiff,
+  getRecordsDiff,
+  hasRecordsDiff,
+} from "./diff";
+import type {
+  ChangeSource,
+  RecordsDiff,
+  ScopedStoreRecord,
+  StoreChange,
+  StoreRecord,
+  StoreScopeOf,
+} from "./types";
+
+type StoreListener<TRecord extends StoreRecord> = (
+  change: StoreChange<TRecord>,
+) => void;
+type ScopedRecord<TRecord extends StoreRecord> = Extract<
+  TRecord,
+  ScopedStoreRecord
+>;
+
+export class Store<TRecord extends StoreRecord = StoreRecord> {
+  readonly recordsSignal: Atom<Map<string, TRecord>>;
+
+  private readonly listeners = new Set<StoreListener<TRecord>>();
+  private transactionDepth = 0;
+  private draftRecords: Map<string, TRecord> | null = null;
+  private pendingSource: ChangeSource = "system";
+
+  constructor(initialRecords: TRecord[]) {
+    this.recordsSignal = atom(
+      "store.records",
+      new Map(initialRecords.map((record) => [record.id, record])),
+    );
+  }
+
+  get(id: string): TRecord | undefined {
+    return this.getReadableRecords().get(id);
+  }
+
+  getAll(): TRecord[] {
+    return Array.from(this.getReadableRecords().values());
+  }
+
+  getByScope<TScope extends StoreScopeOf<ScopedRecord<TRecord>>>(
+    scope: TScope,
+  ): Array<Extract<ScopedRecord<TRecord>, { scope: TScope }>> {
+    return this.getAll().filter(
+      (record): record is Extract<ScopedRecord<TRecord>, { scope: TScope }> =>
+        "scope" in record && record.scope === scope,
+    );
+  }
+
+  listen(listener: StoreListener<TRecord>): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  atomic(fn: () => void, source: ChangeSource = "system"): void {
+    const isOuter = this.transactionDepth === 0;
+    if (isOuter) {
+      this.draftRecords = new Map(this.recordsSignal.get());
+      this.pendingSource = source;
+    }
+
+    this.transactionDepth += 1;
+    let thrown: unknown;
+
+    try {
+      fn();
+    } catch (error) {
+      thrown = error;
+    }
+
+    this.transactionDepth -= 1;
+
+    if (isOuter) {
+      const previous = this.recordsSignal.get();
+      const next = this.draftRecords;
+      const pendingSource = this.pendingSource;
+      this.draftRecords = null;
+      this.pendingSource = "system";
+      const diff = next ? getRecordsDiff(previous, next) : createEmptyRecordsDiff<TRecord>();
+
+      if (!thrown && next && hasRecordsDiff(diff)) {
+        this.recordsSignal.set(next);
+        const change = {
+          source: pendingSource,
+          diff,
+        } satisfies StoreChange<TRecord>;
+        for (const notify of this.listeners) {
+          notify(change);
+        }
+      }
+    }
+
+    if (thrown) {
+      throw thrown;
+    }
+  }
+
+  put(records: TRecord[], source: ChangeSource = "system"): void {
+    this.atomic(() => {
+      const target = this.getMutableRecords();
+      for (const record of records) {
+        const previous = target.get(record.id);
+        if (previous === record) continue;
+        target.set(record.id, record);
+      }
+    }, source);
+  }
+
+  remove(ids: string[], source: ChangeSource = "system"): void {
+    this.atomic(() => {
+      const target = this.getMutableRecords();
+      for (const id of ids) {
+        if (!target.delete(id)) continue;
+      }
+    }, source);
+  }
+
+  replaceAll(records: TRecord[], source: ChangeSource = "system"): void {
+    const next = new Map(records.map((record) => [record.id, record]));
+    const diff = getRecordsDiff(this.recordsSignal.get(), next);
+    if (!hasRecordsDiff(diff)) {
+      return;
+    }
+    this.recordsSignal.set(next);
+    const change = {
+      source,
+      diff,
+    } satisfies StoreChange<TRecord>;
+    for (const notify of this.listeners) {
+      notify(change);
+    }
+  }
+
+  applyDiff<TChangeRecord extends TRecord>(
+    diff: RecordsDiff<TChangeRecord>,
+    source: ChangeSource = "system",
+  ): void {
+    this.atomic(() => {
+      const target = this.getMutableRecords();
+
+      for (const record of diff.added) {
+        target.set(record.id, record);
+      }
+
+      for (const update of diff.updated) {
+        target.set(update.after.id, update.after);
+      }
+
+      for (const record of diff.removed) {
+        target.delete(record.id);
+      }
+    }, source);
+  }
+
+  private getMutableRecords(): Map<string, TRecord> {
+    if (!this.draftRecords) {
+      throw new Error("Store mutations must run inside store.atomic");
+    }
+    return this.draftRecords;
+  }
+
+  private getReadableRecords(): Map<string, TRecord> {
+    return this.draftRecords ?? this.recordsSignal.get();
+  }
+}

package/_vendor/store/diff.ts

@@ -0,0 +1,229 @@
+import type {
+  RecordUpdate,
+  RecordsDiff,
+  StoreRecord,
+} from "./types";
+
+function isMap<TRecord extends StoreRecord>(
+  value: Map<string, TRecord> | Iterable<TRecord>,
+): value is Map<string, TRecord> {
+  return value instanceof Map;
+}
+
+export function createEmptyRecordsDiff<
+  TRecord extends StoreRecord,
+>(): RecordsDiff<TRecord> {
+  return {
+    added: [],
+    updated: [],
+    removed: [],
+  };
+}
+
+export function hasRecordsDiff<TRecord extends StoreRecord>(
+  diff: RecordsDiff<TRecord>,
+): boolean {
+  return diff.added.length > 0 || diff.updated.length > 0 || diff.removed.length > 0;
+}
+
+export function getRecordMap<TRecord extends StoreRecord>(
+  records: Map<string, TRecord> | Iterable<TRecord>,
+): Map<string, TRecord> {
+  return isMap(records)
+    ? new Map(records)
+    : new Map(Array.from(records, (record) => [record.id, record]));
+}
+
+export function getRecordsDiff<TRecord extends StoreRecord>(
+  before: Map<string, TRecord> | Iterable<TRecord>,
+  after: Map<string, TRecord> | Iterable<TRecord>,
+): RecordsDiff<TRecord> {
+  const beforeMap = getRecordMap(before);
+  const afterMap = getRecordMap(after);
+  const diff = createEmptyRecordsDiff<TRecord>();
+
+  for (const [id, previous] of beforeMap) {
+    const next = afterMap.get(id);
+    if (!next) {
+      diff.removed.push(previous);
+      continue;
+    }
+
+    if (next !== previous) {
+      diff.updated.push({
+        before: previous,
+        after: next,
+      });
+    }
+  }
+
+  for (const [id, next] of afterMap) {
+    if (!beforeMap.has(id)) {
+      diff.added.push(next);
+    }
+  }
+
+  return diff;
+}
+
+export function invertRecordsDiff<TRecord extends StoreRecord>(
+  diff: RecordsDiff<TRecord>,
+): RecordsDiff<TRecord> {
+  return {
+    added: [...diff.removed],
+    updated: diff.updated.map(
+      (update): RecordUpdate<TRecord> => ({
+        before: update.after,
+        after: update.before,
+      }),
+    ),
+    removed: [...diff.added],
+  };
+}
+
+export function composeRecordsDiff<
+  TRecord extends StoreRecord,
+  TNextRecord extends TRecord,
+>(
+  left: RecordsDiff<TRecord>,
+  right: RecordsDiff<TNextRecord>,
+): RecordsDiff<TRecord | TNextRecord> {
+  const added = new Map<string, TRecord | TNextRecord>();
+  const updated = new Map<string, RecordUpdate<TRecord | TNextRecord>>();
+  const removed = new Map<string, TRecord | TNextRecord>();
+
+  for (const record of left.added) {
+    added.set(record.id, record);
+  }
+
+  for (const update of left.updated) {
+    updated.set(update.after.id, update);
+  }
+
+  for (const record of left.removed) {
+    removed.set(record.id, record);
+  }
+
+  for (const record of right.added) {
+    const existingRemoved = removed.get(record.id);
+    if (existingRemoved) {
+      removed.delete(record.id);
+      updated.set(record.id, {
+        before: existingRemoved,
+        after: record,
+      });
+      continue;
+    }
+
+    const existingUpdated = updated.get(record.id);
+    if (existingUpdated) {
+      updated.set(record.id, {
+        before: existingUpdated.before,
+        after: record,
+      });
+      continue;
+    }
+
+    added.set(record.id, record);
+  }
+
+  for (const change of right.updated) {
+    const existingAdded = added.get(change.after.id);
+    if (existingAdded) {
+      added.set(change.after.id, change.after);
+      continue;
+    }
+
+    const existingRemoved = removed.get(change.after.id);
+    if (existingRemoved) {
+      removed.delete(change.after.id);
+      updated.set(change.after.id, {
+        before: existingRemoved,
+        after: change.after,
+      });
+      continue;
+    }
+
+    const existingUpdated = updated.get(change.after.id);
+    if (existingUpdated) {
+      updated.set(change.after.id, {
+        before: existingUpdated.before,
+        after: change.after,
+      });
+      continue;
+    }
+
+    updated.set(change.after.id, {
+      before: change.before,
+      after: change.after,
+    });
+  }
+
+  for (const record of right.removed) {
+    const existingAdded = added.get(record.id);
+    if (existingAdded) {
+      added.delete(record.id);
+      continue;
+    }
+
+    const existingUpdated = updated.get(record.id);
+    if (existingUpdated) {
+      updated.delete(record.id);
+      removed.set(record.id, existingUpdated.before);
+      continue;
+    }
+
+    removed.set(record.id, record);
+  }
+
+  const next = createEmptyRecordsDiff<TRecord | TNextRecord>();
+
+  for (const record of added.values()) {
+    next.added.push(record);
+  }
+
+  for (const change of updated.values()) {
+    if (change.before === change.after) {
+      continue;
+    }
+    next.updated.push(change);
+  }
+
+  for (const record of removed.values()) {
+    next.removed.push(record);
+  }
+
+  return next;
+}
+
+export function squashRecordsDiffs<
+  TRecord extends StoreRecord,
+  TNextRecord extends TRecord,
+>(
+  diffs: Iterable<RecordsDiff<TRecord> | RecordsDiff<TNextRecord>>,
+): RecordsDiff<TRecord | TNextRecord> {
+  let next = createEmptyRecordsDiff<TRecord | TNextRecord>();
+  for (const diff of diffs) {
+    next = composeRecordsDiff(next, diff);
+  }
+  return next;
+}
+
+export function filterRecordsDiff<
+  TRecord extends StoreRecord,
+  TFilteredRecord extends TRecord,
+>(
+  diff: RecordsDiff<TRecord>,
+  predicate: (record: TRecord) => record is TFilteredRecord,
+): RecordsDiff<TFilteredRecord> {
+  return {
+    added: diff.added.filter(predicate),
+    updated: diff.updated.filter(
+      (
+        update,
+      ): update is RecordUpdate<TFilteredRecord> =>
+        predicate(update.before) && predicate(update.after),
+    ),
+    removed: diff.removed.filter(predicate),
+  };
+}