@yuzhouu/canvas-kit 0.1.2 → 0.1.3

package/_vendor/signals/core.ts

@@ -1,130 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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/types.ts

@@ -1,17 +0,0 @@
-/** 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

@@ -1,171 +0,0 @@
-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

@@ -1,229 +0,0 @@
-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),
-  };
-}