@number10/jsx-core 5.0.0

package/dist/effects.d.ts

@@ -0,0 +1,152 @@
+import { EffectDefinition as EngineEffectDefinition } from './animation/effect-definitions';
+import { EffectHandle, EffectTarget } from './animation/effect-engine';
+import { EffectConfig as EngineEffectConfig } from './animation/types';
+/**
+ * Built-in effect names available in all renderers.
+ */
+export type BuiltInEffectName = 'none' | 'pulse' | 'shake' | 'bounce' | 'press' | 'flash' | 'jello' | 'fade' | 'fadeIn' | 'fadeOut' | 'wobble' | 'tada' | 'swing' | 'wiggle' | 'slideIn' | 'slideOut' | 'zoomIn' | 'zoomOut' | 'flipIn' | 'flipOut' | 'float' | 'breathe' | 'spin';
+/**
+ * Extension point for custom effect names.
+ * Use declaration merging to add custom effects:
+ *
+ * @example
+ * ```typescript
+ * declare module '@number10/jsx-core' {
+ *   interface EffectNameExtensions {
+ *     squash: 'squash'
+ *   }
+ * }
+ * ```
+ */
+export interface EffectNameExtensions {
+}
+/**
+ * Known effect names (built-in + custom extensions).
+ */
+export type EffectName = BuiltInEffectName | (keyof EffectNameExtensions extends never ? never : keyof EffectNameExtensions);
+/** Configuration for an effect (duration, intensity, direction, etc.). */
+export type EffectConfig = EngineEffectConfig;
+/** Canonical transform origin used by built-in effects across renderers. */
+export type EffectTransformOrigin = import('./animation/effect-definitions').EffectTransformOrigin;
+/**
+ * Props that any component can extend to declare effects.
+ */
+export interface EffectDefinition {
+    /** Effect to apply on interaction (e.g., 'press', 'pulse') */
+    effect?: EffectName | undefined;
+    /** Configuration for the effect */
+    effectConfig?: EffectConfig | undefined;
+}
+/**
+ * Resolve which effect to use from props vs theme.
+ * @param props - Explicit component props
+ * @param theme - Resolved theme (with effect/effectConfig)
+ * @returns The resolved effect name and config
+ */
+export declare function resolveEffect(props: EffectDefinition, theme: Record<string, unknown>): {
+    effect?: EffectName | undefined;
+    effectConfig?: EffectConfig | undefined;
+};
+/**
+ * Default effect configuration used as fallback when no effect is specified.
+ */
+export declare const DEFAULT_EFFECT: {
+    effect: EffectName;
+    effectConfig: EffectConfig;
+};
+/**
+ * Apply an effect by name with automatic DEFAULT_EFFECT fallback.
+ *
+ * Convenience wrapper around a renderer's applyEffect function that fills in
+ * defaults when effect name or config are omitted.
+ *
+ * @param applyFn - Renderer-specific applyEffect function
+ * @param effectName - Name of the effect to apply (defaults to 'pulse')
+ * @param effectConfig - Optional configuration for the effect
+ * @returns true if effect was applied, false otherwise
+ */
+export declare function applyEffectByName(applyFn: (name: EffectName, config?: EffectConfig) => void, effectName?: EffectName, effectConfig?: EffectConfig): boolean;
+/**
+ * Resolve the canonical transform origin for a built-in effect.
+ * Delegates to the central effect-definitions registry.
+ */
+export declare function resolveEffectTransformOrigin(effect: EffectName | undefined): EffectTransformOrigin;
+/**
+ * Register a custom effect definition so it becomes available via
+ * `applyEffect()` and `effect="customName"` in components.
+ *
+ * Combine with declaration merging on `EffectNameExtensions` to maintain
+ * type safety:
+ *
+ * @example
+ * ```typescript
+ * declare module '@number10/jsx-core' {
+ *   interface EffectNameExtensions { squash: 'squash' }
+ * }
+ * registerEffect('squash', {
+ *   name: 'squash',
+ *   steps: (base, config) => [
+ *     { type: 'tween', to: { scaleX: base.scaleX * 1.5, scaleY: base.scaleY / 1.5 },
+ *       duration: config.time ?? 200, ease: 'Sine.easeInOut' },
+ *     { type: 'tween', to: { scaleX: base.scaleX, scaleY: base.scaleY },
+ *       duration: config.time ?? 200 },
+ *   ],
+ *   loop: false,
+ *   origin: 'center',
+ * })
+ * ```
+ *
+ * @param name - Unique effect name
+ * @param definition - Effect definition (steps, loop, origin)
+ */
+export declare function registerEffect(name: string, definition: EngineEffectDefinition): void;
+/** Legacy runner signature — receives a renderer node, effect name, and config */
+export type EffectRunner = (node: unknown, effect: EffectName, config?: EffectConfig) => void;
+export type EffectStopRunner = (node: unknown) => void;
+/**
+ * Register a renderer-specific effect runner (transitional).
+ *
+ * During migration, Pixi/Phaser bridges register runners that create
+ * an EffectTarget internally and delegate to the central engine.
+ * After full migration, this pattern is replaced by direct EffectTarget usage.
+ */
+export declare function registerEffectRunner(runner: EffectRunner): void;
+/**
+ * Register a renderer-specific effect stop runner (transitional).
+ */
+export declare function registerEffectStopRunner(runner: EffectStopRunner): void;
+/**
+ * Apply an effect using the legacy runner-registry dispatch.
+ *
+ * Renderer bridges (Pixi, Phaser) register runners that create an EffectTarget
+ * and delegate to the central engine internally.
+ *
+ * @param node - Renderer-native node (PIXI.Container, Phaser.GameObjects.Container, ...)
+ * @param effect - Effect name to apply
+ * @param config - Effect configuration
+ */
+export declare function applyEffect(node: unknown, effect: EffectName | undefined, config?: EffectConfig): void;
+/**
+ * Apply an effect directly using the central engine.
+ *
+ * Portable components that have an EffectTarget can use this overload
+ * to skip the runner-registry dispatch.
+ *
+ * @param targetKey - Object used as animation state key (typically the renderer node)
+ * @param target - EffectTarget implementation for this renderer
+ * @param effect - Effect name to apply
+ * @param config - Effect configuration
+ * @returns EffectHandle or null if effect is unknown
+ */
+export declare function applyEffect(targetKey: object, target: EffectTarget, effect: EffectName | undefined, config?: EffectConfig): EffectHandle | null;
+/**
+ * Stop effects using the legacy runner-registry dispatch.
+ * @param node - Renderer-native node
+ */
+export declare function stopEffect(node: unknown): void;
+/**
+ * Stop effects directly via the central engine.
+ * @param targetKey - Object used as animation state key
+ */
+export declare function stopEffect(targetKey: object): void;
+//# sourceMappingURL=effects.d.ts.map

package/dist/effects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effects.d.ts","sourceRoot":"","sources":["../src/effects.ts"],"names":[],"mappings":"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"}

package/dist/effects.js

@@ -0,0 +1,69 @@
+import { EFFECT_DEFINITIONS, resolveEffectTransformOrigin as resolveEffectTransformOrigin$1 } from "./animation/effect-definitions.js";
+import { runEffect, stopEffect as stopEffect$1 } from "./animation/effect-engine.js";
+function resolveEffect(props, theme) {
+  return {
+    effect: props.effect ?? theme.effect,
+    effectConfig: props.effectConfig ?? theme.effectConfig
+  };
+}
+const DEFAULT_EFFECT = {
+  effect: "pulse",
+  effectConfig: { intensity: 1.1, time: 100 }
+};
+function applyEffectByName(applyFn, effectName, effectConfig) {
+  const name = effectName ?? DEFAULT_EFFECT.effect;
+  const config = effectConfig ?? DEFAULT_EFFECT.effectConfig;
+  applyFn(name, config);
+  return true;
+}
+function resolveEffectTransformOrigin(effect) {
+  return resolveEffectTransformOrigin$1(effect);
+}
+function registerEffect(name, definition) {
+  EFFECT_DEFINITIONS[name] = definition;
+}
+const _effectRunners = [];
+const _effectStopRunners = [];
+function registerEffectRunner(runner) {
+  _effectRunners.push(runner);
+}
+function registerEffectStopRunner(runner) {
+  _effectStopRunners.push(runner);
+}
+function applyEffect(a, b, c, d) {
+  if (arguments.length === 4 && b && typeof b === "object" && "onUpdate" in b) {
+    const targetKey = a;
+    const target = b;
+    const effect2 = c;
+    const config2 = d ?? {};
+    if (!effect2 || effect2 === "none") return null;
+    const def = EFFECT_DEFINITIONS[effect2];
+    if (!def) return null;
+    return runEffect(targetKey, target, def, config2);
+  }
+  const node = a;
+  const effect = b;
+  const config = c ?? {};
+  if (!effect || effect === "none") return;
+  for (const runner of _effectRunners) {
+    runner(node, effect, config);
+  }
+}
+function stopEffect(key) {
+  stopEffect$1(key);
+  for (const runner of _effectStopRunners) {
+    runner(key);
+  }
+}
+export {
+  DEFAULT_EFFECT,
+  applyEffect,
+  applyEffectByName,
+  registerEffect,
+  registerEffectRunner,
+  registerEffectStopRunner,
+  resolveEffect,
+  resolveEffectTransformOrigin,
+  stopEffect
+};
+//# sourceMappingURL=effects.js.map

package/dist/effects.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effects.js","sources":["../src/effects.ts"],"sourcesContent":["/**\n * Portable effect system — renderer-agnostic effect contracts.\n *\n * Components declare their effect intent via props/theme. The central\n * effect engine (animation/effect-engine.ts) handles all effect execution.\n *\n * ## Portable usage (recommended for new components)\n *\n * Portable components implement `EffectTarget` to connect their node to\n * the central engine. Use the 4-arg `applyEffect()` overload directly:\n *\n * ```typescript\n * import { applyEffect, type EffectTarget } from '@number10/jsx-core'\n *\n * // Inside a portable component:\n * const target: EffectTarget = {\n *   onUpdate: (values) => {\n *     // Apply animated values to the renderer node\n *     node.setPosition(values.x ?? node.x, values.y ?? node.y)\n *     node.alpha = values.alpha ?? node.alpha\n *   },\n *   getSnapshot: () => ({\n *     x: node.x, y: node.y, alpha: node.alpha,\n *     scaleX: node.scaleX, scaleY: node.scaleY,\n *     rotation: node.rotation,\n *   }),\n *   getScheduler: () => surface.scheduler,\n *   getSize: () => ({ width: node.width, height: node.height }),\n * }\n *\n * applyEffect(node, target, 'pulse', { duration: 300 })\n * ```\n *\n * ## Legacy API (transitional)\n *\n * Renderer bridges (Pixi/Phaser) use the 3-arg `applyEffect(node, effect, config)`\n * which dispatches via a runner registry. New components should prefer the\n * direct 4-arg overload above.\n *\n * @migration Transitional architecture — two paths coexist:\n *   1. Legacy: `applyEffect(node, effect, config)` — dispatches via runner registry\n *      (Pixi/Phaser bridges register runners that internally create EffectTargets)\n *   2. Direct: `applyEffect(targetKey, target, effect, config)` — skips runners,\n *      calls the engine directly. Used by portable components that have an EffectTarget.\n */\n\nimport {\n  EFFECT_DEFINITIONS,\n  resolveEffectTransformOrigin as resolveOrigin,\n  type EffectDefinition as EngineEffectDefinition,\n} from './animation/effect-definitions'\nimport {\n  runEffect,\n  stopEffect as stopEngineEffect,\n  type EffectHandle,\n  type EffectTarget,\n} from './animation/effect-engine'\nimport type { EffectConfig as EngineEffectConfig } from './animation/types'\n\n// ---------------------------------------------------------------------------\n// Effect name types — extensible via declaration merging\n// ---------------------------------------------------------------------------\n\n/**\n * Built-in effect names available in all renderers.\n */\nexport type BuiltInEffectName =\n  | 'none'\n  | 'pulse'\n  | 'shake'\n  | 'bounce'\n  | 'press'\n  | 'flash'\n  | 'jello'\n  | 'fade'\n  | 'fadeIn'\n  | 'fadeOut'\n  | 'wobble'\n  | 'tada'\n  | 'swing'\n  | 'wiggle'\n  | 'slideIn'\n  | 'slideOut'\n  | 'zoomIn'\n  | 'zoomOut'\n  | 'flipIn'\n  | 'flipOut'\n  | 'float'\n  | 'breathe'\n  | 'spin'\n\n/**\n * Extension point for custom effect names.\n * Use declaration merging to add custom effects:\n *\n * @example\n * ```typescript\n * declare module '@number10/jsx-core' {\n *   interface EffectNameExtensions {\n *     squash: 'squash'\n *   }\n * }\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-empty-object-type\nexport interface EffectNameExtensions {}\n\n/**\n * Known effect names (built-in + custom extensions).\n */\nexport type EffectName =\n  | BuiltInEffectName\n  | (keyof EffectNameExtensions extends never ? never : keyof EffectNameExtensions)\n\n/** Configuration for an effect (duration, intensity, direction, etc.). */\nexport type EffectConfig = EngineEffectConfig\n\n/** Canonical transform origin used by built-in effects across renderers. */\nexport type EffectTransformOrigin = import('./animation/effect-definitions').EffectTransformOrigin\n\n/**\n * Props that any component can extend to declare effects.\n */\nexport interface EffectDefinition {\n  /** Effect to apply on interaction (e.g., 'press', 'pulse') */\n  effect?: EffectName | undefined\n  /** Configuration for the effect */\n  effectConfig?: EffectConfig | undefined\n}\n\n/**\n * Resolve which effect to use from props vs theme.\n * @param props - Explicit component props\n * @param theme - Resolved theme (with effect/effectConfig)\n * @returns The resolved effect name and config\n */\nexport function resolveEffect(\n  props: EffectDefinition,\n  theme: Record<string, unknown>\n): { effect?: EffectName | undefined; effectConfig?: EffectConfig | undefined } {\n  return {\n    effect: props.effect ?? (theme.effect as EffectName | undefined),\n    effectConfig: props.effectConfig ?? (theme.effectConfig as EffectConfig | undefined),\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Default effect + convenience helper\n// ---------------------------------------------------------------------------\n\n/**\n * Default effect configuration used as fallback when no effect is specified.\n */\nexport const DEFAULT_EFFECT = {\n  effect: 'pulse' as EffectName,\n  effectConfig: { intensity: 1.1, time: 100 } as EffectConfig,\n}\n\n/**\n * Apply an effect by name with automatic DEFAULT_EFFECT fallback.\n *\n * Convenience wrapper around a renderer's applyEffect function that fills in\n * defaults when effect name or config are omitted.\n *\n * @param applyFn - Renderer-specific applyEffect function\n * @param effectName - Name of the effect to apply (defaults to 'pulse')\n * @param effectConfig - Optional configuration for the effect\n * @returns true if effect was applied, false otherwise\n */\nexport function applyEffectByName(\n  applyFn: (name: EffectName, config?: EffectConfig) => void,\n  effectName?: EffectName,\n  effectConfig?: EffectConfig\n): boolean {\n  const name = effectName ?? DEFAULT_EFFECT.effect\n  const config = effectConfig ?? DEFAULT_EFFECT.effectConfig\n\n  applyFn(name, config)\n  return true\n}\n\n/**\n * Resolve the canonical transform origin for a built-in effect.\n * Delegates to the central effect-definitions registry.\n */\nexport function resolveEffectTransformOrigin(\n  effect: EffectName | undefined\n): EffectTransformOrigin {\n  return resolveOrigin(effect)\n}\n\n// ---------------------------------------------------------------------------\n// Custom effect registration\n// ---------------------------------------------------------------------------\n\n/**\n * Register a custom effect definition so it becomes available via\n * `applyEffect()` and `effect=\"customName\"` in components.\n *\n * Combine with declaration merging on `EffectNameExtensions` to maintain\n * type safety:\n *\n * @example\n * ```typescript\n * declare module '@number10/jsx-core' {\n *   interface EffectNameExtensions { squash: 'squash' }\n * }\n * registerEffect('squash', {\n *   name: 'squash',\n *   steps: (base, config) => [\n *     { type: 'tween', to: { scaleX: base.scaleX * 1.5, scaleY: base.scaleY / 1.5 },\n *       duration: config.time ?? 200, ease: 'Sine.easeInOut' },\n *     { type: 'tween', to: { scaleX: base.scaleX, scaleY: base.scaleY },\n *       duration: config.time ?? 200 },\n *   ],\n *   loop: false,\n *   origin: 'center',\n * })\n * ```\n *\n * @param name - Unique effect name\n * @param definition - Effect definition (steps, loop, origin)\n */\nexport function registerEffect(name: string, definition: EngineEffectDefinition): void {\n  EFFECT_DEFINITIONS[name] = definition\n}\n\n// ---------------------------------------------------------------------------\n// Transitional: Runner registry (used by Pixi/Phaser bridges)\n// ---------------------------------------------------------------------------\n\n/** Legacy runner signature — receives a renderer node, effect name, and config */\nexport type EffectRunner = (node: unknown, effect: EffectName, config?: EffectConfig) => void\nexport type EffectStopRunner = (node: unknown) => void\n\nconst _effectRunners: EffectRunner[] = []\nconst _effectStopRunners: EffectStopRunner[] = []\n\n/**\n * Register a renderer-specific effect runner (transitional).\n *\n * During migration, Pixi/Phaser bridges register runners that create\n * an EffectTarget internally and delegate to the central engine.\n * After full migration, this pattern is replaced by direct EffectTarget usage.\n */\nexport function registerEffectRunner(runner: EffectRunner): void {\n  _effectRunners.push(runner)\n}\n\n/**\n * Register a renderer-specific effect stop runner (transitional).\n */\nexport function registerEffectStopRunner(runner: EffectStopRunner): void {\n  _effectStopRunners.push(runner)\n}\n\n// ---------------------------------------------------------------------------\n// Legacy API: applyEffect(node, effect, config) — dispatches via runners\n// ---------------------------------------------------------------------------\n\n/**\n * Apply an effect using the legacy runner-registry dispatch.\n *\n * Renderer bridges (Pixi, Phaser) register runners that create an EffectTarget\n * and delegate to the central engine internally.\n *\n * @param node - Renderer-native node (PIXI.Container, Phaser.GameObjects.Container, ...)\n * @param effect - Effect name to apply\n * @param config - Effect configuration\n */\nexport function applyEffect(\n  node: unknown,\n  effect: EffectName | undefined,\n  config?: EffectConfig\n): void\n\n/**\n * Apply an effect directly using the central engine.\n *\n * Portable components that have an EffectTarget can use this overload\n * to skip the runner-registry dispatch.\n *\n * @param targetKey - Object used as animation state key (typically the renderer node)\n * @param target - EffectTarget implementation for this renderer\n * @param effect - Effect name to apply\n * @param config - Effect configuration\n * @returns EffectHandle or null if effect is unknown\n */\nexport function applyEffect(\n  targetKey: object,\n  target: EffectTarget,\n  effect: EffectName | undefined,\n  config?: EffectConfig\n): EffectHandle | null\n\n/** Implementation — supports both 3-arg (legacy) and 4-arg (direct) signatures */\nexport function applyEffect(\n  a: unknown | object,\n  b: EffectTarget | EffectName | undefined,\n  c?: EffectName | EffectConfig | undefined,\n  d?: EffectConfig\n): void | EffectHandle | null {\n  // 4-arg overload: applyEffect(targetKey, target, effect, config)\n  if (arguments.length === 4 && b && typeof b === 'object' && 'onUpdate' in b) {\n    const targetKey = a as object\n    const target = b as EffectTarget\n    const effect = c as EffectName | undefined\n    const config = (d ?? {}) as EffectConfig\n    if (!effect || effect === 'none') return null\n    const def = EFFECT_DEFINITIONS[effect]\n    if (!def) return null\n    return runEffect(targetKey, target, def, config)\n  }\n\n  // 3-arg overload: applyEffect(node, effect, config) — dispatches via runners\n  const node = a\n  const effect = b as EffectName | undefined\n  const config = (c ?? {}) as EffectConfig\n  if (!effect || effect === 'none') return\n  for (const runner of _effectRunners) {\n    runner(node, effect, config)\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Legacy API: stopEffect(node) — dispatches via runners\n// ---------------------------------------------------------------------------\n\n/**\n * Stop effects using the legacy runner-registry dispatch.\n * @param node - Renderer-native node\n */\nexport function stopEffect(node: unknown): void\n\n/**\n * Stop effects directly via the central engine.\n * @param targetKey - Object used as animation state key\n */\nexport function stopEffect(targetKey: object): void\n\n/** Implementation */\nexport function stopEffect(key: unknown | object): void {\n  // Check if we should use the engine directly (only if it's likely an engine-tracked key)\n  // The engine tracks via WeakMap, so calling with any object is safe\n  stopEngineEffect(key as object)\n\n  // Also dispatch via legacy stop runners for backward compatibility\n  for (const runner of _effectStopRunners) {\n    runner(key)\n  }\n}\n"],"names":["resolveOrigin","effect","config","stopEngineEffect"],"mappings":";;AAwIO,SAAS,cACd,OACA,OAC8E;AAC9E,SAAO;AAAA,IACL,QAAQ,MAAM,UAAW,MAAM;AAAA,IAC/B,cAAc,MAAM,gBAAiB,MAAM;AAAA,EAAA;AAE/C;AASO,MAAM,iBAAiB;AAAA,EAC5B,QAAQ;AAAA,EACR,cAAc,EAAE,WAAW,KAAK,MAAM,IAAA;AACxC;AAaO,SAAS,kBACd,SACA,YACA,cACS;AACT,QAAM,OAAO,cAAc,eAAe;AAC1C,QAAM,SAAS,gBAAgB,eAAe;AAE9C,UAAQ,MAAM,MAAM;AACpB,SAAO;AACT;AAMO,SAAS,6BACd,QACuB;AACvB,SAAOA,+BAAc,MAAM;AAC7B;AAkCO,SAAS,eAAe,MAAc,YAA0C;AACrF,qBAAmB,IAAI,IAAI;AAC7B;AAUA,MAAM,iBAAiC,CAAA;AACvC,MAAM,qBAAyC,CAAA;AASxC,SAAS,qBAAqB,QAA4B;AAC/D,iBAAe,KAAK,MAAM;AAC5B;AAKO,SAAS,yBAAyB,QAAgC;AACvE,qBAAmB,KAAK,MAAM;AAChC;AA0CO,SAAS,YACd,GACA,GACA,GACA,GAC4B;AAE5B,MAAI,UAAU,WAAW,KAAK,KAAK,OAAO,MAAM,YAAY,cAAc,GAAG;AAC3E,UAAM,YAAY;AAClB,UAAM,SAAS;AACf,UAAMC,UAAS;AACf,UAAMC,UAAU,KAAK,CAAA;AACrB,QAAI,CAACD,WAAUA,YAAW,OAAQ,QAAO;AACzC,UAAM,MAAM,mBAAmBA,OAAM;AACrC,QAAI,CAAC,IAAK,QAAO;AACjB,WAAO,UAAU,WAAW,QAAQ,KAAKC,OAAM;AAAA,EACjD;AAGA,QAAM,OAAO;AACb,QAAM,SAAS;AACf,QAAM,SAAU,KAAK,CAAA;AACrB,MAAI,CAAC,UAAU,WAAW,OAAQ;AAClC,aAAW,UAAU,gBAAgB;AACnC,WAAO,MAAM,QAAQ,MAAM;AAAA,EAC7B;AACF;AAmBO,SAAS,WAAW,KAA6B;AAGtDC,eAAiB,GAAa;AAG9B,aAAW,UAAU,oBAAoB;AACvC,WAAO,GAAG;AAAA,EACZ;AACF;"}

package/dist/global-registry.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function getGlobalObject() {
+  if (typeof globalThis !== "undefined") return globalThis;
+  if (typeof window !== "undefined") return window;
+  if (typeof global !== "undefined") return global;
+  return {};
+}
+function getGlobalValue(key) {
+  return getGlobalObject()[key];
+}
+function setGlobalValue(key, value) {
+  getGlobalObject()[key] = value;
+}
+function getOrCreateGlobalValue(key, create) {
+  const existing = getGlobalValue(key);
+  if (existing !== void 0) return existing;
+  const next = create();
+  setGlobalValue(key, next);
+  return next;
+}
+exports.getGlobalValue = getGlobalValue;
+exports.getOrCreateGlobalValue = getOrCreateGlobalValue;
+exports.setGlobalValue = setGlobalValue;
+//# sourceMappingURL=global-registry.cjs.map

package/dist/global-registry.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-registry.cjs","sources":["../src/global-registry.ts"],"sourcesContent":["type GlobalRegistry = Record<string | symbol, unknown>\n\n/**\n * Resolve the process-wide global object for the current JavaScript realm.\n *\n * Core uses this registry to share state across duplicated module instances\n * produced by some bundlers (e.g. Parcel in workspace/symlink scenarios).\n */\nfunction getGlobalObject(): GlobalRegistry {\n  if (typeof globalThis !== 'undefined') return globalThis as GlobalRegistry\n  if (typeof window !== 'undefined') return window as unknown as GlobalRegistry\n  if (typeof global !== 'undefined') return global as unknown as GlobalRegistry\n  return {}\n}\n\n/**\n * Read a value from the shared global registry.\n *\n * Returns `undefined` when no value has been registered for the given key.\n */\nexport function getGlobalValue<T>(key: symbol): T | undefined {\n  return getGlobalObject()[key] as T | undefined\n}\n\n/**\n * Store a value in the shared global registry.\n *\n * Callers should use stable `Symbol.for(...)` keys so independently bundled\n * module copies address the same slot.\n */\nexport function setGlobalValue<T>(key: symbol, value: T): void {\n  getGlobalObject()[key] = value\n}\n\n/**\n * Read a value from the shared global registry, creating and storing it on\n * first access when it does not exist yet.\n */\nexport function getOrCreateGlobalValue<T>(key: symbol, create: () => T): T {\n  const existing = getGlobalValue<T>(key)\n  if (existing !== undefined) return existing\n\n  const next = create()\n  setGlobalValue(key, next)\n  return next\n}\n"],"names":[],"mappings":";;AAQA,SAAS,kBAAkC;AACzC,MAAI,OAAO,eAAe,YAAa,QAAO;AAC9C,MAAI,OAAO,WAAW,YAAa,QAAO;AAC1C,MAAI,OAAO,WAAW,YAAa,QAAO;AAC1C,SAAO,CAAA;AACT;AAOO,SAAS,eAAkB,KAA4B;AAC5D,SAAO,gBAAA,EAAkB,GAAG;AAC9B;AAQO,SAAS,eAAkB,KAAa,OAAgB;AAC7D,kBAAA,EAAkB,GAAG,IAAI;AAC3B;AAMO,SAAS,uBAA0B,KAAa,QAAoB;AACzE,QAAM,WAAW,eAAkB,GAAG;AACtC,MAAI,aAAa,OAAW,QAAO;AAEnC,QAAM,OAAO,OAAA;AACb,iBAAe,KAAK,IAAI;AACxB,SAAO;AACT;;;;"}

package/dist/global-registry.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Read a value from the shared global registry.
+ *
+ * Returns `undefined` when no value has been registered for the given key.
+ */
+export declare function getGlobalValue<T>(key: symbol): T | undefined;
+/**
+ * Store a value in the shared global registry.
+ *
+ * Callers should use stable `Symbol.for(...)` keys so independently bundled
+ * module copies address the same slot.
+ */
+export declare function setGlobalValue<T>(key: symbol, value: T): void;
+/**
+ * Read a value from the shared global registry, creating and storing it on
+ * first access when it does not exist yet.
+ */
+export declare function getOrCreateGlobalValue<T>(key: symbol, create: () => T): T;
+//# sourceMappingURL=global-registry.d.ts.map

package/dist/global-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-registry.d.ts","sourceRoot":"","sources":["../src/global-registry.ts"],"names":[],"mappings":"AAeA;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAE5D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAE7D;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,CAOzE"}

package/dist/global-registry.js

@@ -0,0 +1,25 @@
+function getGlobalObject() {
+  if (typeof globalThis !== "undefined") return globalThis;
+  if (typeof window !== "undefined") return window;
+  if (typeof global !== "undefined") return global;
+  return {};
+}
+function getGlobalValue(key) {
+  return getGlobalObject()[key];
+}
+function setGlobalValue(key, value) {
+  getGlobalObject()[key] = value;
+}
+function getOrCreateGlobalValue(key, create) {
+  const existing = getGlobalValue(key);
+  if (existing !== void 0) return existing;
+  const next = create();
+  setGlobalValue(key, next);
+  return next;
+}
+export {
+  getGlobalValue,
+  getOrCreateGlobalValue,
+  setGlobalValue
+};
+//# sourceMappingURL=global-registry.js.map

package/dist/global-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-registry.js","sources":["../src/global-registry.ts"],"sourcesContent":["type GlobalRegistry = Record<string | symbol, unknown>\n\n/**\n * Resolve the process-wide global object for the current JavaScript realm.\n *\n * Core uses this registry to share state across duplicated module instances\n * produced by some bundlers (e.g. Parcel in workspace/symlink scenarios).\n */\nfunction getGlobalObject(): GlobalRegistry {\n  if (typeof globalThis !== 'undefined') return globalThis as GlobalRegistry\n  if (typeof window !== 'undefined') return window as unknown as GlobalRegistry\n  if (typeof global !== 'undefined') return global as unknown as GlobalRegistry\n  return {}\n}\n\n/**\n * Read a value from the shared global registry.\n *\n * Returns `undefined` when no value has been registered for the given key.\n */\nexport function getGlobalValue<T>(key: symbol): T | undefined {\n  return getGlobalObject()[key] as T | undefined\n}\n\n/**\n * Store a value in the shared global registry.\n *\n * Callers should use stable `Symbol.for(...)` keys so independently bundled\n * module copies address the same slot.\n */\nexport function setGlobalValue<T>(key: symbol, value: T): void {\n  getGlobalObject()[key] = value\n}\n\n/**\n * Read a value from the shared global registry, creating and storing it on\n * first access when it does not exist yet.\n */\nexport function getOrCreateGlobalValue<T>(key: symbol, create: () => T): T {\n  const existing = getGlobalValue<T>(key)\n  if (existing !== undefined) return existing\n\n  const next = create()\n  setGlobalValue(key, next)\n  return next\n}\n"],"names":[],"mappings":"AAQA,SAAS,kBAAkC;AACzC,MAAI,OAAO,eAAe,YAAa,QAAO;AAC9C,MAAI,OAAO,WAAW,YAAa,QAAO;AAC1C,MAAI,OAAO,WAAW,YAAa,QAAO;AAC1C,SAAO,CAAA;AACT;AAOO,SAAS,eAAkB,KAA4B;AAC5D,SAAO,gBAAA,EAAkB,GAAG;AAC9B;AAQO,SAAS,eAAkB,KAAa,OAAgB;AAC7D,kBAAA,EAAkB,GAAG,IAAI;AAC3B;AAMO,SAAS,uBAA0B,KAAa,QAAoB;AACzE,QAAM,WAAW,eAAkB,GAAG;AACtC,MAAI,aAAa,OAAW,QAAO;AAEnC,QAAM,OAAO,OAAA;AACb,iBAAe,KAAK,IAAI;AACxB,SAAO;AACT;"}