@pibbl/core 0.0.1

package/dist/lib/hooks/use-animated-value.d.ts

@@ -0,0 +1,24 @@
+import type { PibblSpringAnimatedValueOptions, PibblTweenAnimatedValueOptions } from '../animation/types.js';
+import type { Signal, SignalValue } from '../signals/types.js';
+/**
+ * Animates a numeric target using an analytic spring. See {@link PibblSpringAnimatedValueOptions}
+ * and {@link Signal}.
+ * @param target - Target value or signal whose changes start transitions. See {@link SignalValue}.
+ * @param options - Spring or tween configuration, including signal-backed fields. See
+ * {@link SignalValue} , {@link PibblSpringAnimatedValueOptions} .
+ * @returns A readonly signal containing the animated value. See {@link Signal}.
+ */
+export declare function useAnimatedValue(target: SignalValue<number>, options: SignalValue<{
+    readonly [K in keyof PibblSpringAnimatedValueOptions]: SignalValue<PibblSpringAnimatedValueOptions[K]>;
+}>): Signal<number>;
+/**
+ * Animates a target using a tween and optional custom interpolation. See
+ * {@link PibblTweenAnimatedValueOptions} and {@link Signal}.
+ * @param target - Target value or signal whose changes start transitions. See {@link SignalValue}.
+ * @param options - Spring or tween configuration, including signal-backed fields. See
+ * {@link SignalValue} , {@link PibblTweenAnimatedValueOptions} .
+ * @returns A readonly signal containing the animated value. See {@link Signal}.
+ */
+export declare function useAnimatedValue<T>(target: SignalValue<T>, options: SignalValue<{
+    readonly [K in keyof PibblTweenAnimatedValueOptions<T>]: SignalValue<PibblTweenAnimatedValueOptions<T>[K]>;
+}>): Signal<T>;

package/dist/lib/hooks/use-animated-value.js

@@ -0,0 +1,169 @@
+import {
+  createAnimationPlaybackController
+} from "../animation/playback.js";
+import { spring, tween } from "../animation/definition.js";
+import { drive } from "../animation/program.js";
+import { GLOBAL_STATE } from "../global-state.js";
+import {
+  isSignal,
+  provisionSignalValueForRender,
+  signal,
+  untracked
+} from "../signals/graph.js";
+import { resolveSignalValue } from "../signals/resolve-signal-value.js";
+import { requireHookContext, useHookSlot } from "./hook-slot.js";
+function hasOwn(value, key) {
+  return Object.prototype.hasOwnProperty.call(value, key);
+}
+function normalizeCandidate(target, options) {
+  if (typeof options !== "object" || options === null) {
+    throw new TypeError("Pibbl transition options must be an object.");
+  }
+  if (options.type !== "tween" && options.type !== "spring") {
+    throw new TypeError('Pibbl transition type must be "tween" or "spring".');
+  }
+  if (options.equals !== void 0 && typeof options.equals !== "function") {
+    throw new TypeError("Pibbl transition equals must be a function.");
+  }
+  const snapshot = Object.freeze({ ...options });
+  if (snapshot.type === "spring") {
+    spring({
+      from: target,
+      to: target,
+      mass: snapshot.mass,
+      stiffness: snapshot.stiffness,
+      damping: snapshot.damping,
+      initialVelocity: snapshot.initialVelocity,
+      restSpeed: snapshot.restSpeed,
+      restDelta: snapshot.restDelta,
+      maxDuration: snapshot.maxDuration,
+      debugName: snapshot.debugName
+    });
+  } else {
+    tween({
+      from: target,
+      to: target,
+      duration: snapshot.duration,
+      easing: snapshot.easing,
+      interpolate: snapshot.interpolate,
+      debugName: snapshot.debugName
+    });
+  }
+  const hasInitial = hasOwn(options, "initial");
+  return Object.freeze({
+    options: snapshot,
+    equals: snapshot.equals ?? Object.is,
+    hasInitial,
+    initial: hasInitial ? snapshot.initial : target,
+    target
+  });
+}
+function programFor(output, from, candidate, springVelocity) {
+  const options = candidate.options;
+  if (options.type === "spring") {
+    return drive(output, spring({
+      from,
+      to: candidate.target,
+      mass: options.mass,
+      stiffness: options.stiffness,
+      damping: options.damping,
+      initialVelocity: springVelocity ?? options.initialVelocity,
+      restSpeed: options.restSpeed,
+      restDelta: options.restDelta,
+      maxDuration: options.maxDuration,
+      debugName: options.debugName
+    }));
+  }
+  return drive(output, tween({
+    from,
+    to: candidate.target,
+    duration: options.duration,
+    easing: options.easing,
+    interpolate: options.interpolate,
+    debugName: options.debugName
+  }));
+}
+function isCurrentSlot(slot) {
+  return !slot.componentRefs.teardowns.closed && !slot.pibblInstance.mainTeardowns.closed && GLOBAL_STATE.pibblInstances.get(slot.pibblInstance.canvas) === slot.pibblInstance && slot.pibblInstance.refs.get(slot.componentRefs.id) === slot.componentRefs;
+}
+function useAnimatedValue(targetInput, optionsInput) {
+  const { componentRefs, pibblInstance } = requireHookContext();
+  const target = resolveSignalValue(targetInput);
+  const options = resolveTransitionOptions(optionsInput);
+  const candidate = normalizeCandidate(target, options);
+  const slot = useHookSlot("transition", (teardowns) => {
+    const output = signal(candidate.initial);
+    const program = programFor(output, candidate.initial, candidate);
+    const controller = createAnimationPlaybackController(program, {
+      conflict: "replace",
+      debugName: candidate.options.debugName
+    });
+    const value = {
+      componentRefs,
+      controller,
+      pibblInstance,
+      output,
+      readonlyOutput: output.asReadonly(),
+      renderRevision: 0,
+      settled: false,
+      target: candidate.target
+    };
+    teardowns.add(() => controller.dispose());
+    return value;
+  }).value;
+  const shouldEnter = !slot.settled && candidate.hasInitial && !candidate.equals(candidate.initial, candidate.target);
+  const shouldRetarget = slot.settled && !candidate.equals(slot.target, candidate.target);
+  const previousProvisionalValue = untracked(() => slot.output.get());
+  const hasProvisionalValue = !slot.settled && !Object.is(previousProvisionalValue, candidate.initial);
+  const transaction = GLOBAL_STATE.renderTransaction;
+  if (!transaction) {
+    throw new Error("useAnimatedValue requires an active Pibbl render transaction.");
+  }
+  if (hasProvisionalValue) {
+    provisionSignalValueForRender(slot.output, candidate.initial, transaction);
+  }
+  const revision = ++slot.renderRevision;
+  transaction.onFinish((success) => {
+    if (!success) return;
+    if (revision !== slot.renderRevision || !isCurrentSlot(slot)) return;
+    slot.settled = true;
+    slot.target = candidate.target;
+    if (!shouldEnter && !shouldRetarget) {
+      slot.controller.adopt(
+        programFor(slot.output, slot.output.get(), candidate),
+        {
+          conflict: "replace",
+          debugName: candidate.options.debugName
+        }
+      );
+      return;
+    }
+    const springVelocity = candidate.options.type === "spring" ? slot.controller.committedSpringSnapshot()?.velocity : void 0;
+    const program = programFor(
+      slot.output,
+      slot.output.get(),
+      candidate,
+      springVelocity
+    );
+    slot.controller.retarget(program, {
+      conflict: "replace",
+      debugName: candidate.options.debugName
+    });
+  });
+  return slot.readonlyOutput;
+}
+function resolveTransitionOptions(input) {
+  const source = resolveSignalValue(input);
+  let resolved;
+  for (const key in source) {
+    const value = source[key];
+    if (!isSignal(value)) continue;
+    resolved ??= { ...source };
+    resolved[key] = resolveSignalValue(value);
+  }
+  return resolved ?? source;
+}
+export {
+  useAnimatedValue
+};
+//# sourceMappingURL=use-animated-value.js.map

package/dist/lib/hooks/use-animated-value.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/hooks/use-animated-value.ts"],
+  "sourcesContent": ["import {\n  createAnimationPlaybackController,\n  type AnimationPlaybackController,\n} from '../animation/playback.js';\nimport { spring, tween } from '../animation/definition.js';\nimport { drive } from '../animation/program.js';\nimport type {\n  PibblAnimationProgram,\n  PibblSpringAnimatedValueOptions,\n  PibblTweenAnimatedValueOptions,\n} from '../animation/types.js';\nimport { GLOBAL_STATE } from '../global-state.js';\nimport {\n  isSignal,\n  provisionSignalValueForRender,\n  signal,\n  untracked,\n} from '../signals/graph.js';\nimport { resolveSignalValue } from '../signals/resolve-signal-value.js';\nimport type {\n  Signal,\n  SignalEquals,\n  SignalValue,\n  WritableSignal,\n} from '../signals/types.js';\nimport type { PibblComponentRefs, PibblInstance } from '../types.js';\nimport { requireHookContext, useHookSlot } from './hook-slot.js';\n\ntype PibblTransitionOptions<T> =\n  | PibblTweenAnimatedValueOptions<T>\n  | PibblSpringAnimatedValueOptions;\n\ntype PibblTransitionOptionsInput<T> =\n  | {\n      readonly [K in keyof PibblTweenAnimatedValueOptions<T>]:\n        SignalValue<PibblTweenAnimatedValueOptions<T>[K]>;\n    }\n  | {\n      readonly [K in keyof PibblSpringAnimatedValueOptions]:\n        SignalValue<PibblSpringAnimatedValueOptions[K]>;\n    };\n\ninterface PibblTransitionCandidate<T> {\n  readonly options: PibblTransitionOptions<T>;\n  readonly equals: SignalEquals<T>;\n  readonly hasInitial: boolean;\n  readonly initial: T;\n  readonly target: T;\n}\n\ninterface PibblTransitionHookSlot<T> {\n  readonly componentRefs: PibblComponentRefs<any>;\n  readonly controller: AnimationPlaybackController;\n  readonly pibblInstance: PibblInstance;\n  readonly output: WritableSignal<T>;\n  readonly readonlyOutput: Signal<T>;\n  renderRevision: number;\n  settled: boolean;\n  target: T;\n}\n\nfunction hasOwn(value: object, key: PropertyKey): boolean {\n  return Object.prototype.hasOwnProperty.call(value, key);\n}\n\nfunction normalizeCandidate<T>(\n  target: T,\n  options: PibblTransitionOptions<T>,\n): PibblTransitionCandidate<T> {\n  if (typeof options !== 'object' || options === null) {\n    throw new TypeError('Pibbl transition options must be an object.');\n  }\n  if (options.type !== 'tween' && options.type !== 'spring') {\n    throw new TypeError('Pibbl transition type must be \"tween\" or \"spring\".');\n  }\n  if (options.equals !== undefined && typeof options.equals !== 'function') {\n    throw new TypeError('Pibbl transition equals must be a function.');\n  }\n  const snapshot = Object.freeze({ ...options }) as PibblTransitionOptions<T>;\n  if (snapshot.type === 'spring') {\n    spring({\n      from: target as number,\n      to: target as number,\n      mass: snapshot.mass,\n      stiffness: snapshot.stiffness,\n      damping: snapshot.damping,\n      initialVelocity: snapshot.initialVelocity,\n      restSpeed: snapshot.restSpeed,\n      restDelta: snapshot.restDelta,\n      maxDuration: snapshot.maxDuration,\n      debugName: snapshot.debugName,\n    });\n  } else {\n    tween({\n      from: target,\n      to: target,\n      duration: snapshot.duration,\n      easing: snapshot.easing,\n      interpolate: snapshot.interpolate,\n      debugName: snapshot.debugName,\n    });\n  }\n  const hasInitial = hasOwn(options, 'initial');\n  return Object.freeze({\n    options: snapshot,\n    equals: (snapshot.equals ?? Object.is) as SignalEquals<T>,\n    hasInitial,\n    initial: (hasInitial ? snapshot.initial : target) as T,\n    target,\n  });\n}\n\nfunction programFor<T>(\n  output: WritableSignal<T>,\n  from: T,\n  candidate: PibblTransitionCandidate<T>,\n  springVelocity?: number,\n): PibblAnimationProgram {\n  const options = candidate.options;\n  if (options.type === 'spring') {\n    return drive(output as unknown as WritableSignal<number>, spring({\n      from: from as number,\n      to: candidate.target as number,\n      mass: options.mass,\n      stiffness: options.stiffness,\n      damping: options.damping,\n      initialVelocity: springVelocity ?? options.initialVelocity,\n      restSpeed: options.restSpeed,\n      restDelta: options.restDelta,\n      maxDuration: options.maxDuration,\n      debugName: options.debugName,\n    }));\n  }\n  return drive(output, tween({\n    from,\n    to: candidate.target,\n    duration: options.duration,\n    easing: options.easing,\n    interpolate: options.interpolate,\n    debugName: options.debugName,\n  }));\n}\n\nfunction isCurrentSlot<T>(slot: PibblTransitionHookSlot<T>): boolean {\n  return !slot.componentRefs.teardowns.closed &&\n    !slot.pibblInstance.mainTeardowns.closed &&\n    GLOBAL_STATE.pibblInstances.get(slot.pibblInstance.canvas) === slot.pibblInstance &&\n    slot.pibblInstance.refs.get(slot.componentRefs.id) === slot.componentRefs;\n}\n\n/**\n * Animates a numeric target using an analytic spring. See {@link PibblSpringAnimatedValueOptions}\n * and {@link Signal}.\n * @param target - Target value or signal whose changes start transitions. See {@link SignalValue}.\n * @param options - Spring or tween configuration, including signal-backed fields. See\n * {@link SignalValue} , {@link PibblSpringAnimatedValueOptions} .\n * @returns A readonly signal containing the animated value. See {@link Signal}.\n */\nexport function useAnimatedValue(\n  target: SignalValue<number>,\n  options: SignalValue<{\n    readonly [K in keyof PibblSpringAnimatedValueOptions]:\n      SignalValue<PibblSpringAnimatedValueOptions[K]>;\n  }>,\n): Signal<number>;\n/**\n * Animates a target using a tween and optional custom interpolation. See\n * {@link PibblTweenAnimatedValueOptions} and {@link Signal}.\n * @param target - Target value or signal whose changes start transitions. See {@link SignalValue}.\n * @param options - Spring or tween configuration, including signal-backed fields. See\n * {@link SignalValue} , {@link PibblTweenAnimatedValueOptions} .\n * @returns A readonly signal containing the animated value. See {@link Signal}.\n */\nexport function useAnimatedValue<T>(\n  target: SignalValue<T>,\n  options: SignalValue<{\n    readonly [K in keyof PibblTweenAnimatedValueOptions<T>]:\n      SignalValue<PibblTweenAnimatedValueOptions<T>[K]>;\n  }>,\n): Signal<T>;\n/**\n * Returns a mount-owned signal that animates toward the current target using the supplied\n * transition options.\n *\n * @param targetInput - Target value or signal whose changes start transitions. See\n * {@link SignalValue} .\n * @param optionsInput - Spring or tween configuration, including signal-backed fields. See\n * {@link SignalValue} , {@link PibblTransitionOptionsInput} .\n * @returns A readonly signal containing the animated value. See {@link Signal}.\n *\n * @see {@link SignalValue}\n * @see {@link Signal}\n */\nexport function useAnimatedValue<T>(\n  targetInput: SignalValue<T>,\n  optionsInput: SignalValue<PibblTransitionOptionsInput<T>>,\n): Signal<T> {\n  const { componentRefs, pibblInstance } = requireHookContext();\n  const target = resolveSignalValue(targetInput);\n  const options = resolveTransitionOptions(optionsInput);\n  const candidate = normalizeCandidate(target, options);\n  const slot = useHookSlot<PibblTransitionHookSlot<T>>('transition', teardowns => {\n    const output = signal(candidate.initial);\n    const program = programFor(output, candidate.initial, candidate);\n    const controller = createAnimationPlaybackController(program, {\n      conflict: 'replace',\n      debugName: candidate.options.debugName,\n    });\n    const value: PibblTransitionHookSlot<T> = {\n      componentRefs,\n      controller,\n      pibblInstance,\n      output,\n      readonlyOutput: output.asReadonly(),\n      renderRevision: 0,\n      settled: false,\n      target: candidate.target,\n    };\n    teardowns.add(() => controller.dispose());\n    return value;\n  }).value;\n\n  const shouldEnter = !slot.settled && candidate.hasInitial &&\n    !candidate.equals(candidate.initial, candidate.target);\n  const shouldRetarget = slot.settled &&\n    !candidate.equals(slot.target, candidate.target);\n  const previousProvisionalValue = untracked(() => slot.output.get());\n  const hasProvisionalValue = !slot.settled &&\n    !Object.is(previousProvisionalValue, candidate.initial);\n  const transaction = GLOBAL_STATE.renderTransaction;\n  if (!transaction) {\n    throw new Error('useAnimatedValue requires an active Pibbl render transaction.');\n  }\n  if (hasProvisionalValue) {\n    provisionSignalValueForRender(slot.output, candidate.initial, transaction);\n  }\n  const revision = ++slot.renderRevision;\n  transaction.onFinish(success => {\n    if (!success) return;\n    if (revision !== slot.renderRevision || !isCurrentSlot(slot)) return;\n    slot.settled = true;\n    slot.target = candidate.target;\n    if (!shouldEnter && !shouldRetarget) {\n      slot.controller.adopt(\n        programFor(slot.output, slot.output.get(), candidate),\n        {\n          conflict: 'replace',\n          debugName: candidate.options.debugName,\n        },\n      );\n      return;\n    }\n    const springVelocity = candidate.options.type === 'spring' ?\n      slot.controller.committedSpringSnapshot()?.velocity : undefined;\n    const program = programFor(\n      slot.output,\n      slot.output.get(),\n      candidate,\n      springVelocity,\n    );\n    slot.controller.retarget(program, {\n      conflict: 'replace',\n      debugName: candidate.options.debugName,\n    });\n  });\n  return slot.readonlyOutput;\n}\n\nfunction resolveTransitionOptions<T>(\n  input: SignalValue<PibblTransitionOptionsInput<T>>,\n): PibblTransitionOptions<T> {\n  const source = resolveSignalValue(input);\n  let resolved: Record<PropertyKey, unknown> | undefined;\n  for (const key in source) {\n    const value = source[key as keyof typeof source];\n    if (!isSignal(value)) continue;\n    resolved ??= { ...source };\n    resolved[key] = resolveSignalValue(value as SignalValue<unknown>);\n  }\n  return (resolved ?? source) as PibblTransitionOptions<T>;\n}\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,OAEK;AACP,SAAS,QAAQ,aAAa;AAC9B,SAAS,aAAa;AAMtB,SAAS,oBAAoB;AAC7B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,0BAA0B;AAQnC,SAAS,oBAAoB,mBAAmB;AAmChD,SAAS,OAAO,OAAe,KAA2B;AACxD,SAAO,OAAO,UAAU,eAAe,KAAK,OAAO,GAAG;AACxD;AAEA,SAAS,mBACP,QACA,SAC6B;AAC7B,MAAI,OAAO,YAAY,YAAY,YAAY,MAAM;AACnD,UAAM,IAAI,UAAU,6CAA6C;AAAA,EACnE;AACA,MAAI,QAAQ,SAAS,WAAW,QAAQ,SAAS,UAAU;AACzD,UAAM,IAAI,UAAU,oDAAoD;AAAA,EAC1E;AACA,MAAI,QAAQ,WAAW,UAAa,OAAO,QAAQ,WAAW,YAAY;AACxE,UAAM,IAAI,UAAU,6CAA6C;AAAA,EACnE;AACA,QAAM,WAAW,OAAO,OAAO,EAAE,GAAG,QAAQ,CAAC;AAC7C,MAAI,SAAS,SAAS,UAAU;AAC9B,WAAO;AAAA,MACL,MAAM;AAAA,MACN,IAAI;AAAA,MACJ,MAAM,SAAS;AAAA,MACf,WAAW,SAAS;AAAA,MACpB,SAAS,SAAS;AAAA,MAClB,iBAAiB,SAAS;AAAA,MAC1B,WAAW,SAAS;AAAA,MACpB,WAAW,SAAS;AAAA,MACpB,aAAa,SAAS;AAAA,MACtB,WAAW,SAAS;AAAA,IACtB,CAAC;AAAA,EACH,OAAO;AACL,UAAM;AAAA,MACJ,MAAM;AAAA,MACN,IAAI;AAAA,MACJ,UAAU,SAAS;AAAA,MACnB,QAAQ,SAAS;AAAA,MACjB,aAAa,SAAS;AAAA,MACtB,WAAW,SAAS;AAAA,IACtB,CAAC;AAAA,EACH;AACA,QAAM,aAAa,OAAO,SAAS,SAAS;AAC5C,SAAO,OAAO,OAAO;AAAA,IACnB,SAAS;AAAA,IACT,QAAS,SAAS,UAAU,OAAO;AAAA,IACnC;AAAA,IACA,SAAU,aAAa,SAAS,UAAU;AAAA,IAC1C;AAAA,EACF,CAAC;AACH;AAEA,SAAS,WACP,QACA,MACA,WACA,gBACuB;AACvB,QAAM,UAAU,UAAU;AAC1B,MAAI,QAAQ,SAAS,UAAU;AAC7B,WAAO,MAAM,QAA6C,OAAO;AAAA,MAC/D;AAAA,MACA,IAAI,UAAU;AAAA,MACd,MAAM,QAAQ;AAAA,MACd,WAAW,QAAQ;AAAA,MACnB,SAAS,QAAQ;AAAA,MACjB,iBAAiB,kBAAkB,QAAQ;AAAA,MAC3C,WAAW,QAAQ;AAAA,MACnB,WAAW,QAAQ;AAAA,MACnB,aAAa,QAAQ;AAAA,MACrB,WAAW,QAAQ;AAAA,IACrB,CAAC,CAAC;AAAA,EACJ;AACA,SAAO,MAAM,QAAQ,MAAM;AAAA,IACzB;AAAA,IACA,IAAI,UAAU;AAAA,IACd,UAAU,QAAQ;AAAA,IAClB,QAAQ,QAAQ;AAAA,IAChB,aAAa,QAAQ;AAAA,IACrB,WAAW,QAAQ;AAAA,EACrB,CAAC,CAAC;AACJ;AAEA,SAAS,cAAiB,MAA2C;AACnE,SAAO,CAAC,KAAK,cAAc,UAAU,UACnC,CAAC,KAAK,cAAc,cAAc,UAClC,aAAa,eAAe,IAAI,KAAK,cAAc,MAAM,MAAM,KAAK,iBACpE,KAAK,cAAc,KAAK,IAAI,KAAK,cAAc,EAAE,MAAM,KAAK;AAChE;AA6CO,SAAS,iBACd,aACA,cACW;AACX,QAAM,EAAE,eAAe,cAAc,IAAI,mBAAmB;AAC5D,QAAM,SAAS,mBAAmB,WAAW;AAC7C,QAAM,UAAU,yBAAyB,YAAY;AACrD,QAAM,YAAY,mBAAmB,QAAQ,OAAO;AACpD,QAAM,OAAO,YAAwC,cAAc,eAAa;AAC9E,UAAM,SAAS,OAAO,UAAU,OAAO;AACvC,UAAM,UAAU,WAAW,QAAQ,UAAU,SAAS,SAAS;AAC/D,UAAM,aAAa,kCAAkC,SAAS;AAAA,MAC5D,UAAU;AAAA,MACV,WAAW,UAAU,QAAQ;AAAA,IAC/B,CAAC;AACD,UAAM,QAAoC;AAAA,MACxC;AAAA,MACA;AAAA,MACA;AAAA,MACA;AAAA,MACA,gBAAgB,OAAO,WAAW;AAAA,MAClC,gBAAgB;AAAA,MAChB,SAAS;AAAA,MACT,QAAQ,UAAU;AAAA,IACpB;AACA,cAAU,IAAI,MAAM,WAAW,QAAQ,CAAC;AACxC,WAAO;AAAA,EACT,CAAC,EAAE;AAEH,QAAM,cAAc,CAAC,KAAK,WAAW,UAAU,cAC7C,CAAC,UAAU,OAAO,UAAU,SAAS,UAAU,MAAM;AACvD,QAAM,iBAAiB,KAAK,WAC1B,CAAC,UAAU,OAAO,KAAK,QAAQ,UAAU,MAAM;AACjD,QAAM,2BAA2B,UAAU,MAAM,KAAK,OAAO,IAAI,CAAC;AAClE,QAAM,sBAAsB,CAAC,KAAK,WAChC,CAAC,OAAO,GAAG,0BAA0B,UAAU,OAAO;AACxD,QAAM,cAAc,aAAa;AACjC,MAAI,CAAC,aAAa;AAChB,UAAM,IAAI,MAAM,+DAA+D;AAAA,EACjF;AACA,MAAI,qBAAqB;AACvB,kCAA8B,KAAK,QAAQ,UAAU,SAAS,WAAW;AAAA,EAC3E;AACA,QAAM,WAAW,EAAE,KAAK;AACxB,cAAY,SAAS,aAAW;AAC9B,QAAI,CAAC,QAAS;AACd,QAAI,aAAa,KAAK,kBAAkB,CAAC,cAAc,IAAI,EAAG;AAC9D,SAAK,UAAU;AACf,SAAK,SAAS,UAAU;AACxB,QAAI,CAAC,eAAe,CAAC,gBAAgB;AACnC,WAAK,WAAW;AAAA,QACd,WAAW,KAAK,QAAQ,KAAK,OAAO,IAAI,GAAG,SAAS;AAAA,QACpD;AAAA,UACE,UAAU;AAAA,UACV,WAAW,UAAU,QAAQ;AAAA,QAC/B;AAAA,MACF;AACA;AAAA,IACF;AACA,UAAM,iBAAiB,UAAU,QAAQ,SAAS,WAChD,KAAK,WAAW,wBAAwB,GAAG,WAAW;AACxD,UAAM,UAAU;AAAA,MACd,KAAK;AAAA,MACL,KAAK,OAAO,IAAI;AAAA,MAChB;AAAA,MACA;AAAA,IACF;AACA,SAAK,WAAW,SAAS,SAAS;AAAA,MAChC,UAAU;AAAA,MACV,WAAW,UAAU,QAAQ;AAAA,IAC/B,CAAC;AAAA,EACH,CAAC;AACD,SAAO,KAAK;AACd;AAEA,SAAS,yBACP,OAC2B;AAC3B,QAAM,SAAS,mBAAmB,KAAK;AACvC,MAAI;AACJ,aAAW,OAAO,QAAQ;AACxB,UAAM,QAAQ,OAAO,GAA0B;AAC/C,QAAI,CAAC,SAAS,KAAK,EAAG;AACtB,iBAAa,EAAE,GAAG,OAAO;AACzB,aAAS,GAAG,IAAI,mBAAmB,KAA6B;AAAA,EAClE;AACA,SAAQ,YAAY;AACtB;",
+  "names": []
+}

package/dist/lib/hooks/use-canvas-context.d.ts

@@ -0,0 +1,10 @@
+import type { RenderingContext2D } from '../types.js';
+/**
+ * Returns the current component's isolated Canvas 2D context.
+ *
+ * @returns The active Canvas 2D rendering context for this component evaluation. See
+ * {@link RenderingContext2D} .
+ *
+ * @see {@link RenderingContext2D}
+ */
+export declare function useCanvasContext(): RenderingContext2D;

package/dist/lib/hooks/use-canvas-context.js

@@ -0,0 +1,13 @@
+import { GLOBAL_STATE } from "../global-state.js";
+const PIBBL_CANVAS_CONTEXT_ERROR = "useCanvasContext() is available only during Pibbl rendering and cannot be used during pure measurement.";
+function useCanvasContext() {
+  const context = GLOBAL_STATE.renderContext;
+  if (!context || GLOBAL_STATE.backendDriver?.name !== "canvas2d" || !GLOBAL_STATE.componentRefs || !GLOBAL_STATE.currentPibblInstance || !GLOBAL_STATE.canvas) {
+    throw new Error(PIBBL_CANVAS_CONTEXT_ERROR);
+  }
+  return context;
+}
+export {
+  useCanvasContext
+};
+//# sourceMappingURL=use-canvas-context.js.map

package/dist/lib/hooks/use-canvas-context.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/hooks/use-canvas-context.ts"],
+  "sourcesContent": ["import { GLOBAL_STATE } from '../global-state.js';\nimport type { RenderingContext2D } from '../types.js';\n\nconst PIBBL_CANVAS_CONTEXT_ERROR =\n  'useCanvasContext() is available only during Pibbl rendering and cannot be ' +\n  'used during pure measurement.';\n\n/**\n * Returns the current component's isolated Canvas 2D context.\n *\n * @returns The active Canvas 2D rendering context for this component evaluation. See\n * {@link RenderingContext2D} .\n *\n * @see {@link RenderingContext2D}\n */\nexport function useCanvasContext(): RenderingContext2D {\n  const context = GLOBAL_STATE.renderContext;\n  if (\n    !context ||\n    GLOBAL_STATE.backendDriver?.name !== 'canvas2d' ||\n    !GLOBAL_STATE.componentRefs ||\n    !GLOBAL_STATE.currentPibblInstance ||\n    !GLOBAL_STATE.canvas\n  ) {\n    throw new Error(PIBBL_CANVAS_CONTEXT_ERROR);\n  }\n  return context;\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB;AAG7B,MAAM,6BACJ;AAWK,SAAS,mBAAuC;AACrD,QAAM,UAAU,aAAa;AAC7B,MACE,CAAC,WACD,aAAa,eAAe,SAAS,cACrC,CAAC,aAAa,iBACd,CAAC,aAAa,wBACd,CAAC,aAAa,QACd;AACA,UAAM,IAAI,MAAM,0BAA0B;AAAA,EAC5C;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/lib/hooks/use-computed.d.ts

@@ -0,0 +1,13 @@
+import type { Signal, SignalOptions } from '../signals/types.js';
+/**
+ * Creates one component-owned lazy computed signal for a mounted hook slot.
+ *
+ * @param compute - Synchronous calculation whose signal reads are tracked.
+ * @param dependencies - Values controlling replacement of the captured computation.
+ * @param options - Equality comparison and optional diagnostic name. See {@link SignalOptions}.
+ * @returns A mount-owned readonly computed signal. See {@link Signal}.
+ *
+ * @see {@link SignalOptions}
+ * @see {@link Signal}
+ */
+export declare function useComputed<T>(compute: () => T, dependencies?: readonly unknown[], options?: SignalOptions<T>): Signal<T>;

package/dist/lib/hooks/use-computed.js

@@ -0,0 +1,91 @@
+import { GLOBAL_STATE } from "../global-state.js";
+import {
+  adoptComputedFormulaCandidate,
+  computed,
+  createComputedFormulaCandidate,
+  createComputedSignalAlias,
+  readComputedFormulaCandidate,
+  replaceComputedFormula
+} from "../signals/graph.js";
+import {
+  requireHookContext,
+  useHookSlot,
+  withHooksForbidden
+} from "./hook-slot.js";
+function useComputed(compute, dependencies, options) {
+  const { componentRefs, pibblInstance } = requireHookContext();
+  const formula = guardedFormula(compute);
+  const dependencySnapshot = snapshotDependencies(dependencies);
+  const slot = useHookSlot("computed", () => {
+    const output = computed(formula, options);
+    const candidates = /* @__PURE__ */ new WeakMap();
+    const signal = createComputedSignalAlias(output, () => {
+      const transaction2 = GLOBAL_STATE.renderTransaction;
+      const candidate2 = transaction2 === void 0 ? void 0 : candidates.get(transaction2);
+      return candidate2 === void 0 ? output.get() : readComputedFormulaCandidate(output, candidate2);
+    });
+    return {
+      candidates,
+      componentRefs,
+      pibblInstance,
+      dependencies: dependencySnapshot,
+      output,
+      signal,
+      renderRevision: 0
+    };
+  }).value;
+  const transaction = GLOBAL_STATE.renderTransaction;
+  if (!transaction) {
+    throw new Error("useComputed requires an active Pibbl render transaction.");
+  }
+  const dependenciesChanged = !dependencySnapshotsEqual(
+    slot.dependencies,
+    dependencySnapshot
+  );
+  const candidate = dependenciesChanged ? createComputedFormulaCandidate(slot.output, formula) : void 0;
+  if (candidate !== void 0) slot.candidates.set(transaction, candidate);
+  const revision = ++slot.renderRevision;
+  transaction.onFinish((success) => {
+    if (candidate !== void 0 && slot.candidates.get(transaction) === candidate) {
+      slot.candidates.delete(transaction);
+    }
+    if (!success || revision !== slot.renderRevision || !isCurrentSlot(slot)) {
+      return;
+    }
+    if (candidate === void 0) {
+      replaceComputedFormula(slot.output, formula, false);
+      return;
+    }
+    slot.dependencies = dependencySnapshot;
+    if (candidate.evaluated) {
+      adoptComputedFormulaCandidate(slot.output, candidate, formula);
+    } else {
+      replaceComputedFormula(slot.output, formula, true);
+    }
+  });
+  return slot.signal;
+}
+function guardedFormula(compute) {
+  return () => withHooksForbidden(
+    "Pibbl hooks cannot be called inside a useComputed formula.",
+    compute
+  );
+}
+function snapshotDependencies(dependencies) {
+  return dependencies === void 0 ? void 0 : [...dependencies];
+}
+function dependencySnapshotsEqual(previous, next) {
+  if (previous === void 0 || next === void 0) return previous === next;
+  if (previous.length !== next.length) return false;
+  for (let index = 0; index < previous.length; index++) {
+    if (!Object.is(previous[index], next[index])) return false;
+  }
+  return true;
+}
+function isCurrentSlot(slot) {
+  return !slot.componentRefs.teardowns.closed && !slot.pibblInstance.mainTeardowns.closed && GLOBAL_STATE.pibblInstances.get(slot.pibblInstance.canvas) === slot.pibblInstance && slot.pibblInstance.refs.get(slot.componentRefs.id) === slot.componentRefs;
+}
+export {
+  useComputed
+};
+//# sourceMappingURL=use-computed.js.map

package/dist/lib/hooks/use-computed.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/hooks/use-computed.ts"],
+  "sourcesContent": ["import { GLOBAL_STATE } from '../global-state.js';\nimport type { PibblComponentRefs, PibblInstance, PibblRenderTransaction } from '../types.js';\nimport {\n  adoptComputedFormulaCandidate,\n  computed,\n  createComputedFormulaCandidate,\n  createComputedSignalAlias,\n  readComputedFormulaCandidate,\n  replaceComputedFormula,\n  type ComputedFormulaCandidate,\n} from '../signals/graph.js';\nimport type { Signal, SignalOptions } from '../signals/types.js';\nimport {\n  requireHookContext,\n  useHookSlot,\n  withHooksForbidden,\n} from './hook-slot.js';\n\ninterface PibblComputedHookSlot<T> {\n  readonly candidates: WeakMap<\n    PibblRenderTransaction,\n    ComputedFormulaCandidate<T>\n  >;\n  readonly componentRefs: PibblComponentRefs<any>;\n  readonly pibblInstance: PibblInstance;\n  dependencies: readonly unknown[] | undefined;\n  readonly output: Signal<T>;\n  readonly signal: Signal<T>;\n  renderRevision: number;\n}\n\n/**\n * Creates one component-owned lazy computed signal for a mounted hook slot.\n *\n * @param compute - Synchronous calculation whose signal reads are tracked.\n * @param dependencies - Values controlling replacement of the captured computation.\n * @param options - Equality comparison and optional diagnostic name. See {@link SignalOptions}.\n * @returns A mount-owned readonly computed signal. See {@link Signal}.\n *\n * @see {@link SignalOptions}\n * @see {@link Signal}\n */\nexport function useComputed<T>(\n  compute: () => T,\n  dependencies?: readonly unknown[],\n  options?: SignalOptions<T>,\n): Signal<T> {\n  const { componentRefs, pibblInstance } = requireHookContext();\n  const formula = guardedFormula(compute);\n  const dependencySnapshot = snapshotDependencies(dependencies);\n  const slot = useHookSlot<PibblComputedHookSlot<T>>('computed', () => {\n    const output = computed(formula, options);\n    const candidates = new WeakMap<\n      PibblRenderTransaction,\n      ComputedFormulaCandidate<T>\n    >();\n    const signal = createComputedSignalAlias(output, () => {\n      const transaction = GLOBAL_STATE.renderTransaction;\n      const candidate = transaction === undefined ? undefined :\n        candidates.get(transaction);\n      return candidate === undefined ? output.get() :\n        readComputedFormulaCandidate(output, candidate);\n    });\n    return {\n      candidates,\n      componentRefs,\n      pibblInstance,\n      dependencies: dependencySnapshot,\n      output,\n      signal,\n      renderRevision: 0,\n    };\n  }).value;\n\n  const transaction = GLOBAL_STATE.renderTransaction;\n  if (!transaction) {\n    throw new Error('useComputed requires an active Pibbl render transaction.');\n  }\n  const dependenciesChanged = !dependencySnapshotsEqual(\n    slot.dependencies,\n    dependencySnapshot,\n  );\n  const candidate = dependenciesChanged ?\n    createComputedFormulaCandidate(slot.output, formula) : undefined;\n  if (candidate !== undefined) slot.candidates.set(transaction, candidate);\n\n  const revision = ++slot.renderRevision;\n  transaction.onFinish(success => {\n    if (\n      candidate !== undefined &&\n      slot.candidates.get(transaction) === candidate\n    ) {\n      slot.candidates.delete(transaction);\n    }\n    if (!success || revision !== slot.renderRevision || !isCurrentSlot(slot)) {\n      return;\n    }\n    if (candidate === undefined) {\n      replaceComputedFormula(slot.output, formula, false);\n      return;\n    }\n\n    slot.dependencies = dependencySnapshot;\n    if (candidate.evaluated) {\n      adoptComputedFormulaCandidate(slot.output, candidate, formula);\n    } else {\n      replaceComputedFormula(slot.output, formula, true);\n    }\n  });\n  return slot.signal;\n}\n\nfunction guardedFormula<T>(compute: () => T): () => T {\n  return () => withHooksForbidden(\n    'Pibbl hooks cannot be called inside a useComputed formula.',\n    compute,\n  );\n}\n\nfunction snapshotDependencies(\n  dependencies: readonly unknown[] | undefined,\n): readonly unknown[] | undefined {\n  return dependencies === undefined ? undefined : [...dependencies];\n}\n\nfunction dependencySnapshotsEqual(\n  previous: readonly unknown[] | undefined,\n  next: readonly unknown[] | undefined,\n): boolean {\n  if (previous === undefined || next === undefined) return previous === next;\n  if (previous.length !== next.length) return false;\n  for (let index = 0; index < previous.length; index++) {\n    if (!Object.is(previous[index], next[index])) return false;\n  }\n  return true;\n}\n\nfunction isCurrentSlot(slot: PibblComputedHookSlot<unknown>): boolean {\n  return !slot.componentRefs.teardowns.closed &&\n    !slot.pibblInstance.mainTeardowns.closed &&\n    GLOBAL_STATE.pibblInstances.get(slot.pibblInstance.canvas) === slot.pibblInstance &&\n    slot.pibblInstance.refs.get(slot.componentRefs.id) === slot.componentRefs;\n}\n"],
+  "mappings": "AAAA,SAAS,oBAAoB;AAE7B;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AAEP;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AA0BA,SAAS,YACd,SACA,cACA,SACW;AACX,QAAM,EAAE,eAAe,cAAc,IAAI,mBAAmB;AAC5D,QAAM,UAAU,eAAe,OAAO;AACtC,QAAM,qBAAqB,qBAAqB,YAAY;AAC5D,QAAM,OAAO,YAAsC,YAAY,MAAM;AACnE,UAAM,SAAS,SAAS,SAAS,OAAO;AACxC,UAAM,aAAa,oBAAI,QAGrB;AACF,UAAM,SAAS,0BAA0B,QAAQ,MAAM;AACrD,YAAMA,eAAc,aAAa;AACjC,YAAMC,aAAYD,iBAAgB,SAAY,SAC5C,WAAW,IAAIA,YAAW;AAC5B,aAAOC,eAAc,SAAY,OAAO,IAAI,IAC1C,6BAA6B,QAAQA,UAAS;AAAA,IAClD,CAAC;AACD,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA,cAAc;AAAA,MACd;AAAA,MACA;AAAA,MACA,gBAAgB;AAAA,IAClB;AAAA,EACF,CAAC,EAAE;AAEH,QAAM,cAAc,aAAa;AACjC,MAAI,CAAC,aAAa;AAChB,UAAM,IAAI,MAAM,0DAA0D;AAAA,EAC5E;AACA,QAAM,sBAAsB,CAAC;AAAA,IAC3B,KAAK;AAAA,IACL;AAAA,EACF;AACA,QAAM,YAAY,sBAChB,+BAA+B,KAAK,QAAQ,OAAO,IAAI;AACzD,MAAI,cAAc,OAAW,MAAK,WAAW,IAAI,aAAa,SAAS;AAEvE,QAAM,WAAW,EAAE,KAAK;AACxB,cAAY,SAAS,aAAW;AAC9B,QACE,cAAc,UACd,KAAK,WAAW,IAAI,WAAW,MAAM,WACrC;AACA,WAAK,WAAW,OAAO,WAAW;AAAA,IACpC;AACA,QAAI,CAAC,WAAW,aAAa,KAAK,kBAAkB,CAAC,cAAc,IAAI,GAAG;AACxE;AAAA,IACF;AACA,QAAI,cAAc,QAAW;AAC3B,6BAAuB,KAAK,QAAQ,SAAS,KAAK;AAClD;AAAA,IACF;AAEA,SAAK,eAAe;AACpB,QAAI,UAAU,WAAW;AACvB,oCAA8B,KAAK,QAAQ,WAAW,OAAO;AAAA,IAC/D,OAAO;AACL,6BAAuB,KAAK,QAAQ,SAAS,IAAI;AAAA,IACnD;AAAA,EACF,CAAC;AACD,SAAO,KAAK;AACd;AAEA,SAAS,eAAkB,SAA2B;AACpD,SAAO,MAAM;AAAA,IACX;AAAA,IACA;AAAA,EACF;AACF;AAEA,SAAS,qBACP,cACgC;AAChC,SAAO,iBAAiB,SAAY,SAAY,CAAC,GAAG,YAAY;AAClE;AAEA,SAAS,yBACP,UACA,MACS;AACT,MAAI,aAAa,UAAa,SAAS,OAAW,QAAO,aAAa;AACtE,MAAI,SAAS,WAAW,KAAK,OAAQ,QAAO;AAC5C,WAAS,QAAQ,GAAG,QAAQ,SAAS,QAAQ,SAAS;AACpD,QAAI,CAAC,OAAO,GAAG,SAAS,KAAK,GAAG,KAAK,KAAK,CAAC,EAAG,QAAO;AAAA,EACvD;AACA,SAAO;AACT;AAEA,SAAS,cAAc,MAA+C;AACpE,SAAO,CAAC,KAAK,cAAc,UAAU,UACnC,CAAC,KAAK,cAAc,cAAc,UAClC,aAAa,eAAe,IAAI,KAAK,cAAc,MAAM,MAAM,KAAK,iBACpE,KAAK,cAAc,KAAK,IAAI,KAAK,cAAc,EAAE,MAAM,KAAK;AAChE;",
+  "names": ["transaction", "candidate"]
+}

package/dist/lib/hooks/use-const.d.ts

@@ -0,0 +1,10 @@
+import type { PibblComponent } from "../element/types.js";
+/**
+ * Creates one non-reactive value for the lifetime of a mounted hook slot.
+ *
+ * @param create - Initializer called once for this mounted hook slot.
+ * @returns The value retained by this hook slot.
+ *
+ * @see {@link PibblComponent}
+ */
+export declare function useConst<T>(create: () => T): T;

package/dist/lib/hooks/use-const.js

@@ -0,0 +1,15 @@
+import { untracked } from "../signals/graph.js";
+import { useHookSlot, withHooksForbidden } from "./hook-slot.js";
+function useConst(create) {
+  return useHookSlot(
+    "const",
+    () => untracked(() => withHooksForbidden(
+      "Pibbl hooks cannot be called inside a useConst factory.",
+      create
+    ))
+  ).value;
+}
+export {
+  useConst
+};
+//# sourceMappingURL=use-const.js.map

package/dist/lib/hooks/use-const.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/hooks/use-const.ts"],
+  "sourcesContent": ["import type { PibblComponent } from '../element/types.js';\nimport { untracked } from '../signals/graph.js';\nimport { useHookSlot, withHooksForbidden } from './hook-slot.js';\n\n/**\n * Creates one non-reactive value for the lifetime of a mounted hook slot.\n *\n * @param create - Initializer called once for this mounted hook slot.\n * @returns The value retained by this hook slot.\n *\n * @see {@link PibblComponent}\n */\nexport function useConst<T>(create: () => T): T {\n  return useHookSlot(\n    'const',\n    () => untracked(() => withHooksForbidden(\n      'Pibbl hooks cannot be called inside a useConst factory.',\n      create,\n    )),\n  ).value;\n}\n"],
+  "mappings": "AACA,SAAS,iBAAiB;AAC1B,SAAS,aAAa,0BAA0B;AAUzC,SAAS,SAAY,QAAoB;AAC9C,SAAO;AAAA,IACL;AAAA,IACA,MAAM,UAAU,MAAM;AAAA,MACpB;AAAA,MACA;AAAA,IACF,CAAC;AAAA,EACH,EAAE;AACJ;",
+  "names": []
+}

package/dist/lib/hooks/use-cursor.d.ts

@@ -0,0 +1,16 @@
+import type { PathGeometry } from '../geometry/path-geometry.js';
+/**
+ * Hook: wires a CSS cursor to the same logical target resolver used by mouse
+ * events. The cursor is released when this hook slot is replaced or removed.
+ *
+ * @param options - Cursor style and optional fill or stroke hit region for the current component.
+ * See {@link PathGeometry} .
+ *
+ * @see {@link PathGeometry}
+ */
+export declare function useCursor({ path, style, fill, lineInteractionWidth, }: {
+    path?: Path2D | PathGeometry;
+    style?: string;
+    fill?: boolean;
+    lineInteractionWidth?: number;
+}): void;

package/dist/lib/hooks/use-cursor.js

@@ -0,0 +1,51 @@
+import { getInteractionRoot } from "../global-state.js";
+import {
+  refreshCursorDefault,
+  removeCursorDefault,
+  updateCursorDefault
+} from "../events/dispatch.js";
+import { requireHookContext, useHookSlot } from "./hook-slot.js";
+import { createRegion, releaseRegion, updateRegion } from "./use-region.js";
+function useCursor({
+  path,
+  style,
+  fill = false,
+  lineInteractionWidth = 0
+}) {
+  const { pibblInstance } = requireHookContext();
+  const interactionRoot = getInteractionRoot(pibblInstance);
+  const slot = useHookSlot("cursor", (teardowns) => {
+    const cursorDefault2 = { style: "" };
+    const region2 = createRegion(pibblInstance);
+    teardowns.add(() => {
+      removeCursorDefault(interactionRoot, cursorDefault2);
+      releaseRegion(pibblInstance, region2);
+    });
+    return { cursorDefault: cursorDefault2, region: region2 };
+  });
+  const { cursorDefault, region } = slot.value;
+  if (path) {
+    removeCursorDefault(interactionRoot, cursorDefault);
+    updateRegion(pibblInstance, region, {
+      path,
+      cursor: style,
+      fill,
+      lineInteractionWidth
+    });
+    return;
+  }
+  releaseRegion(pibblInstance, region);
+  interactionRoot.cursorDefaults.delete(cursorDefault);
+  if (!style) {
+    removeCursorDefault(interactionRoot, cursorDefault);
+    return;
+  }
+  cursorDefault.style = style;
+  interactionRoot.cursorDefaults.add(cursorDefault);
+  updateCursorDefault(interactionRoot, cursorDefault);
+  refreshCursorDefault(interactionRoot);
+}
+export {
+  useCursor
+};
+//# sourceMappingURL=use-cursor.js.map

package/dist/lib/hooks/use-cursor.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/hooks/use-cursor.ts"],
+  "sourcesContent": ["import { getInteractionRoot } from '../global-state.js';\nimport type { PathGeometry } from '../geometry/path-geometry.js';\nimport {\n  refreshCursorDefault,\n  removeCursorDefault,\n  updateCursorDefault,\n} from '../events/dispatch.js';\nimport type {\n  PibblCursorDefault,\n  PibblInteractionRegion,\n} from '../types.js';\nimport { requireHookContext, useHookSlot } from './hook-slot.js';\nimport { createRegion, releaseRegion, updateRegion } from './use-region.js';\n\ninterface PibblCursorDefaultSlot {\n  cursorDefault: PibblCursorDefault;\n  region: PibblInteractionRegion;\n}\n\n/**\n * Hook: wires a CSS cursor to the same logical target resolver used by mouse\n * events. The cursor is released when this hook slot is replaced or removed.\n *\n * @param options - Cursor style and optional fill or stroke hit region for the current component.\n * See {@link PathGeometry} .\n *\n * @see {@link PathGeometry}\n */\nexport function useCursor({\n  path,\n  style,\n  fill = false,\n  lineInteractionWidth = 0,\n}: {\n  path?: Path2D | PathGeometry;\n  style?: string;\n  fill?: boolean;\n  lineInteractionWidth?: number;\n}): void {\n  const { pibblInstance } = requireHookContext();\n  const interactionRoot = getInteractionRoot(pibblInstance);\n  const slot = useHookSlot<PibblCursorDefaultSlot>('cursor', teardowns => {\n    const cursorDefault = { style: '' };\n    const region = createRegion(pibblInstance);\n    teardowns.add(() => {\n      removeCursorDefault(interactionRoot, cursorDefault);\n      releaseRegion(pibblInstance, region);\n    });\n    return { cursorDefault, region };\n  });\n\n  const { cursorDefault, region } = slot.value;\n  if (path) {\n    removeCursorDefault(interactionRoot, cursorDefault);\n    updateRegion(pibblInstance, region, {\n      path,\n      cursor: style,\n      fill,\n      lineInteractionWidth,\n    });\n    return;\n  }\n\n  releaseRegion(pibblInstance, region);\n  interactionRoot.cursorDefaults.delete(cursorDefault);\n  if (!style) {\n    removeCursorDefault(interactionRoot, cursorDefault);\n    return;\n  }\n\n  cursorDefault.style = style;\n  interactionRoot.cursorDefaults.add(cursorDefault);\n  updateCursorDefault(interactionRoot, cursorDefault);\n  refreshCursorDefault(interactionRoot);\n}\n"],
+  "mappings": "AAAA,SAAS,0BAA0B;AAEnC;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAKP,SAAS,oBAAoB,mBAAmB;AAChD,SAAS,cAAc,eAAe,oBAAoB;AAgBnD,SAAS,UAAU;AAAA,EACxB;AAAA,EACA;AAAA,EACA,OAAO;AAAA,EACP,uBAAuB;AACzB,GAKS;AACP,QAAM,EAAE,cAAc,IAAI,mBAAmB;AAC7C,QAAM,kBAAkB,mBAAmB,aAAa;AACxD,QAAM,OAAO,YAAoC,UAAU,eAAa;AACtE,UAAMA,iBAAgB,EAAE,OAAO,GAAG;AAClC,UAAMC,UAAS,aAAa,aAAa;AACzC,cAAU,IAAI,MAAM;AAClB,0BAAoB,iBAAiBD,cAAa;AAClD,oBAAc,eAAeC,OAAM;AAAA,IACrC,CAAC;AACD,WAAO,EAAE,eAAAD,gBAAe,QAAAC,QAAO;AAAA,EACjC,CAAC;AAED,QAAM,EAAE,eAAe,OAAO,IAAI,KAAK;AACvC,MAAI,MAAM;AACR,wBAAoB,iBAAiB,aAAa;AAClD,iBAAa,eAAe,QAAQ;AAAA,MAClC;AAAA,MACA,QAAQ;AAAA,MACR;AAAA,MACA;AAAA,IACF,CAAC;AACD;AAAA,EACF;AAEA,gBAAc,eAAe,MAAM;AACnC,kBAAgB,eAAe,OAAO,aAAa;AACnD,MAAI,CAAC,OAAO;AACV,wBAAoB,iBAAiB,aAAa;AAClD;AAAA,EACF;AAEA,gBAAc,QAAQ;AACtB,kBAAgB,eAAe,IAAI,aAAa;AAChD,sBAAoB,iBAAiB,aAAa;AAClD,uBAAqB,eAAe;AACtC;",
+  "names": ["cursorDefault", "region"]
+}

package/dist/lib/hooks/use-event-listener.d.ts

@@ -0,0 +1,10 @@
+import type { PibblEventHandlers } from '../events/types.js';
+/**
+ * Registers the current component's event handlers with mount-owned cleanup.
+ *
+ * @param handlers - Handlers to register for the current component's event participation. See
+ * {@link PibblEventHandlers} .
+ *
+ * @see {@link PibblEventHandlers}
+ */
+export declare function useEventListener(handlers: PibblEventHandlers): void;

package/dist/lib/hooks/use-event-listener.js

@@ -0,0 +1,24 @@
+import {
+  createListener,
+  releaseListener,
+  updateListener
+} from "../events/registrations.js";
+import { GLOBAL_STATE } from "../global-state.js";
+import { requireHookContext, useHookSlot } from "./hook-slot.js";
+function useEventListener(handlers) {
+  const { componentRefs, pibblInstance } = requireHookContext();
+  const hookIndex = GLOBAL_STATE.componentHookIndex;
+  const slot = useHookSlot(
+    "eventListener",
+    (teardowns) => {
+      const listener = createListener(pibblInstance, componentRefs, hookIndex);
+      teardowns.add(() => releaseListener(listener));
+      return listener;
+    }
+  );
+  updateListener(slot.value, handlers);
+}
+export {
+  useEventListener
+};
+//# sourceMappingURL=use-event-listener.js.map

package/dist/lib/hooks/use-event-listener.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/hooks/use-event-listener.ts"],
+  "sourcesContent": ["import {\n  createListener,\n  releaseListener,\n  updateListener,\n  type PibblEventListenerRegistration,\n} from '../events/registrations.js';\nimport type { PibblEventHandlers } from '../events/types.js';\nimport { GLOBAL_STATE } from '../global-state.js';\nimport { requireHookContext, useHookSlot } from './hook-slot.js';\n\n/**\n * Registers the current component's event handlers with mount-owned cleanup.\n *\n * @param handlers - Handlers to register for the current component's event participation. See\n * {@link PibblEventHandlers} .\n *\n * @see {@link PibblEventHandlers}\n */\nexport function useEventListener(handlers: PibblEventHandlers): void {\n  const { componentRefs, pibblInstance } = requireHookContext();\n  const hookIndex = GLOBAL_STATE.componentHookIndex;\n  const slot = useHookSlot<PibblEventListenerRegistration>(\n    'eventListener',\n    teardowns => {\n      const listener = createListener(pibblInstance, componentRefs, hookIndex);\n      teardowns.add(() => releaseListener(listener));\n      return listener;\n    },\n  );\n  updateListener(slot.value, handlers);\n}\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AAEP,SAAS,oBAAoB;AAC7B,SAAS,oBAAoB,mBAAmB;AAUzC,SAAS,iBAAiB,UAAoC;AACnE,QAAM,EAAE,eAAe,cAAc,IAAI,mBAAmB;AAC5D,QAAM,YAAY,aAAa;AAC/B,QAAM,OAAO;AAAA,IACX;AAAA,IACA,eAAa;AACX,YAAM,WAAW,eAAe,eAAe,eAAe,SAAS;AACvE,gBAAU,IAAI,MAAM,gBAAgB,QAAQ,CAAC;AAC7C,aAAO;AAAA,IACT;AAAA,EACF;AACA,iBAAe,KAAK,OAAO,QAAQ;AACrC;",
+  "names": []
+}

package/dist/lib/hooks/use-event-target.d.ts

@@ -0,0 +1,14 @@
+import type { PibblEventHandlers, PibblEventTargetOptions, PibblEventTargetSnapshot } from '../events/types.js';
+/**
+ * Registers a logical event target and returns its current focus and interaction snapshot.
+ *
+ * @param handlers - Handlers for this logical event target. See {@link PibblEventHandlers}.
+ * @param options - Hit geometry, focus, and target participation options. See
+ * {@link PibblEventTargetOptions} .
+ * @returns The registered target's snapshot. See {@link PibblEventTargetSnapshot}.
+ *
+ * @see {@link PibblEventHandlers}
+ * @see {@link PibblEventTargetOptions}
+ * @see {@link PibblEventTargetSnapshot}
+ */
+export declare function useEventTarget(handlers: PibblEventHandlers, options: PibblEventTargetOptions): PibblEventTargetSnapshot;

package/dist/lib/hooks/use-event-target.js

@@ -0,0 +1,30 @@
+import {
+  createTarget,
+  releaseTarget,
+  updateTarget
+} from "../events/registrations.js";
+import { GLOBAL_STATE } from "../global-state.js";
+import { requireHookContext, useHookSlot } from "./hook-slot.js";
+const UNFOCUSED_SNAPSHOT = Object.freeze({
+  isFocused: false,
+  isFocusVisible: false
+});
+function useEventTarget(handlers, options) {
+  const { componentRefs, pibblInstance } = requireHookContext();
+  const hookIndex = GLOBAL_STATE.componentHookIndex;
+  const slot = useHookSlot(
+    "eventTarget",
+    (teardowns) => {
+      const target2 = createTarget(pibblInstance, componentRefs, hookIndex);
+      teardowns.add(() => releaseTarget(target2));
+      return target2;
+    }
+  );
+  const target = slot.value;
+  updateTarget(target, handlers, options);
+  return pibblInstance.eventRoot.focusPolicy?.snapshot(target) ?? UNFOCUSED_SNAPSHOT;
+}
+export {
+  useEventTarget
+};
+//# sourceMappingURL=use-event-target.js.map

package/dist/lib/hooks/use-event-target.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/lib/hooks/use-event-target.ts"],
+  "sourcesContent": ["import type {\n  PibblEventHandlers,\n  PibblEventTargetOptions,\n  PibblEventTargetSnapshot,\n} from '../events/types.js';\nimport {\n  createTarget,\n  releaseTarget,\n  updateTarget,\n  type PibblEventTargetRegistration,\n} from '../events/registrations.js';\nimport { GLOBAL_STATE } from '../global-state.js';\nimport { requireHookContext, useHookSlot } from './hook-slot.js';\n\nconst UNFOCUSED_SNAPSHOT: PibblEventTargetSnapshot = Object.freeze({\n  isFocused: false,\n  isFocusVisible: false,\n});\n\n/**\n * Registers a logical event target and returns its current focus and interaction snapshot.\n *\n * @param handlers - Handlers for this logical event target. See {@link PibblEventHandlers}.\n * @param options - Hit geometry, focus, and target participation options. See\n * {@link PibblEventTargetOptions} .\n * @returns The registered target's snapshot. See {@link PibblEventTargetSnapshot}.\n *\n * @see {@link PibblEventHandlers}\n * @see {@link PibblEventTargetOptions}\n * @see {@link PibblEventTargetSnapshot}\n */\nexport function useEventTarget(\n  handlers: PibblEventHandlers,\n  options: PibblEventTargetOptions,\n): PibblEventTargetSnapshot {\n  const { componentRefs, pibblInstance } = requireHookContext();\n  const hookIndex = GLOBAL_STATE.componentHookIndex;\n  const slot = useHookSlot<PibblEventTargetRegistration>(\n    'eventTarget',\n    teardowns => {\n      const target = createTarget(pibblInstance, componentRefs, hookIndex);\n      teardowns.add(() => releaseTarget(target));\n      return target;\n    },\n  );\n  const target = slot.value;\n  updateTarget(target, handlers, options);\n  return pibblInstance.eventRoot.focusPolicy?.snapshot(target) ??\n    UNFOCUSED_SNAPSHOT;\n}\n"],
+  "mappings": "AAKA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAEK;AACP,SAAS,oBAAoB;AAC7B,SAAS,oBAAoB,mBAAmB;AAEhD,MAAM,qBAA+C,OAAO,OAAO;AAAA,EACjE,WAAW;AAAA,EACX,gBAAgB;AAClB,CAAC;AAcM,SAAS,eACd,UACA,SAC0B;AAC1B,QAAM,EAAE,eAAe,cAAc,IAAI,mBAAmB;AAC5D,QAAM,YAAY,aAAa;AAC/B,QAAM,OAAO;AAAA,IACX;AAAA,IACA,eAAa;AACX,YAAMA,UAAS,aAAa,eAAe,eAAe,SAAS;AACnE,gBAAU,IAAI,MAAM,cAAcA,OAAM,CAAC;AACzC,aAAOA;AAAA,IACT;AAAA,EACF;AACA,QAAM,SAAS,KAAK;AACpB,eAAa,QAAQ,UAAU,OAAO;AACtC,SAAO,cAAc,UAAU,aAAa,SAAS,MAAM,KACzD;AACJ;",
+  "names": ["target"]
+}

package/dist/lib/hooks/use-layout-box.d.ts

@@ -0,0 +1,9 @@
+import type { LayoutBox } from '../layout/types.js';
+/**
+ * Returns the current stable child-local allocation without scheduling work.
+ *
+ * @returns The current parent-assigned layout box in logical coordinates. See {@link LayoutBox}.
+ *
+ * @see {@link LayoutBox}
+ */
+export declare function useLayoutBox(): Readonly<LayoutBox>;

package/dist/lib/hooks/use-layout-box.js

@@ -0,0 +1,8 @@
+import { getLayoutBox } from "../layout/context.js";
+function useLayoutBox() {
+  return getLayoutBox();
+}
+export {
+  useLayoutBox
+};
+//# sourceMappingURL=use-layout-box.js.map