@motion-core/motion-gpu 0.6.0 → 0.8.0

package/dist/vue/motiongpu-context.d.ts

@@ -0,0 +1,81 @@
+import { type InjectionKey } from 'vue';
+import type { RenderMode } from '../core/types.js';
+import type { CurrentReadable, CurrentWritable } from '../core/current-value.js';
+import type { FrameProfilingSnapshot, FrameRunTimings, FrameScheduleSnapshot } from '../core/frame-registry.js';
+import type { MotionGPUScheduler as CoreMotionGPUScheduler } from '../core/scheduler-helpers.js';
+export type MotionGPUScheduler = CoreMotionGPUScheduler;
+export type { FrameProfilingSnapshot, FrameRunTimings, FrameScheduleSnapshot };
+/**
+ * Namespace identifier for user-owned context entries.
+ */
+export type MotionGPUUserNamespace = string | symbol;
+/**
+ * Shared user context store exposed by `FragCanvas`.
+ */
+export type MotionGPUUserContext = CurrentWritable<Record<MotionGPUUserNamespace, unknown>>;
+/**
+ * Public `FragCanvas` runtime context available to composables and user components.
+ */
+export interface MotionGPUContext {
+    /**
+     * Underlying canvas element used by the renderer.
+     */
+    canvas: HTMLCanvasElement | undefined;
+    /**
+     * Reactive canvas pixel size.
+     */
+    size: CurrentReadable<{
+        width: number;
+        height: number;
+    }>;
+    /**
+     * Device pixel ratio multiplier.
+     */
+    dpr: CurrentWritable<number>;
+    /**
+     * Max frame delta clamp passed to scheduled callbacks.
+     */
+    maxDelta: CurrentWritable<number>;
+    /**
+     * Scheduler render mode (`always`, `on-demand`, `manual`).
+     */
+    renderMode: CurrentWritable<RenderMode>;
+    /**
+     * Global toggle for automatic rendering.
+     */
+    autoRender: CurrentWritable<boolean>;
+    /**
+     * Namespaced user context store shared within the canvas subtree.
+     */
+    user: MotionGPUUserContext;
+    /**
+     * Marks current frame as invalidated.
+     */
+    invalidate: () => void;
+    /**
+     * Requests one manual frame advance.
+     */
+    advance: () => void;
+    /**
+     * Public scheduler API.
+     */
+    scheduler: MotionGPUScheduler;
+}
+/**
+ * Vue injection key used to expose `FragCanvas` runtime state.
+ */
+export declare const motionGPUContextKey: InjectionKey<MotionGPUContext>;
+/**
+ * Registers the motiongpu context in the current Vue component tree.
+ *
+ * @param context - Context payload to provide.
+ */
+export declare function provideMotionGPUContext(context: MotionGPUContext): void;
+/**
+ * Returns the active motiongpu context.
+ *
+ * @returns Active context.
+ * @throws {Error} When called outside `<FragCanvas>`.
+ */
+export declare function useMotionGPU(): MotionGPUContext;
+//# sourceMappingURL=motiongpu-context.d.ts.map

package/dist/vue/motiongpu-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"motiongpu-context.d.ts","sourceRoot":"","sources":["../../src/lib/vue/motiongpu-context.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,KAAK,YAAY,EAAE,MAAM,KAAK,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AACjF,OAAO,KAAK,EACX,sBAAsB,EACtB,eAAe,EACf,qBAAqB,EACrB,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,kBAAkB,IAAI,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAEjG,MAAM,MAAM,kBAAkB,GAAG,sBAAsB,CAAC;AACxD,YAAY,EAAE,sBAAsB,EAAE,eAAe,EAAE,qBAAqB,EAAE,CAAC;AAE/E;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,MAAM,GAAG,MAAM,CAAC;AAErD;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG,eAAe,CAAC,MAAM,CAAC,sBAAsB,EAAE,OAAO,CAAC,CAAC,CAAC;AAE5F;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAChC;;OAEG;IACH,MAAM,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACtC;;OAEG;IACH,IAAI,EAAE,eAAe,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACzD;;OAEG;IACH,GAAG,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;IAC7B;;OAEG;IACH,QAAQ,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;IAClC;;OAEG;IACH,UAAU,EAAE,eAAe,CAAC,UAAU,CAAC,CAAC;IACxC;;OAEG;IACH,UAAU,EAAE,eAAe,CAAC,OAAO,CAAC,CAAC;IACrC;;OAEG;IACH,IAAI,EAAE,oBAAoB,CAAC;IAC3B;;OAEG;IACH,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB;;OAEG;IACH,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB;;OAEG;IACH,SAAS,EAAE,kBAAkB,CAAC;CAC9B;AAED;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,YAAY,CAAC,gBAAgB,CAA+B,CAAC;AAE/F;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAEvE;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,IAAI,gBAAgB,CAO/C"}

package/dist/vue/motiongpu-context.js

@@ -0,0 +1,29 @@
+import { inject, provide } from "vue";
+//#region src/lib/vue/motiongpu-context.ts
+/**
+* Vue injection key used to expose `FragCanvas` runtime state.
+*/
+var motionGPUContextKey = Symbol("motiongpu.context");
+/**
+* Registers the motiongpu context in the current Vue component tree.
+*
+* @param context - Context payload to provide.
+*/
+function provideMotionGPUContext(context) {
+	provide(motionGPUContextKey, context);
+}
+/**
+* Returns the active motiongpu context.
+*
+* @returns Active context.
+* @throws {Error} When called outside `<FragCanvas>`.
+*/
+function useMotionGPU() {
+	const context = inject(motionGPUContextKey, null);
+	if (!context) throw new Error("useMotionGPU must be used inside <FragCanvas>");
+	return context;
+}
+//#endregion
+export { motionGPUContextKey, provideMotionGPUContext, useMotionGPU };
+
+//# sourceMappingURL=motiongpu-context.js.map

package/dist/vue/motiongpu-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"motiongpu-context.js","names":[],"sources":["../../src/lib/vue/motiongpu-context.ts"],"sourcesContent":["import { inject, provide, type InjectionKey } from 'vue';\nimport type { RenderMode } from '../core/types.js';\nimport type { CurrentReadable, CurrentWritable } from '../core/current-value.js';\nimport type {\n\tFrameProfilingSnapshot,\n\tFrameRunTimings,\n\tFrameScheduleSnapshot\n} from '../core/frame-registry.js';\nimport type { MotionGPUScheduler as CoreMotionGPUScheduler } from '../core/scheduler-helpers.js';\n\nexport type MotionGPUScheduler = CoreMotionGPUScheduler;\nexport type { FrameProfilingSnapshot, FrameRunTimings, FrameScheduleSnapshot };\n\n/**\n * Namespace identifier for user-owned context entries.\n */\nexport type MotionGPUUserNamespace = string | symbol;\n\n/**\n * Shared user context store exposed by `FragCanvas`.\n */\nexport type MotionGPUUserContext = CurrentWritable<Record<MotionGPUUserNamespace, unknown>>;\n\n/**\n * Public `FragCanvas` runtime context available to composables and user components.\n */\nexport interface MotionGPUContext {\n\t/**\n\t * Underlying canvas element used by the renderer.\n\t */\n\tcanvas: HTMLCanvasElement | undefined;\n\t/**\n\t * Reactive canvas pixel size.\n\t */\n\tsize: CurrentReadable<{ width: number; height: number }>;\n\t/**\n\t * Device pixel ratio multiplier.\n\t */\n\tdpr: CurrentWritable<number>;\n\t/**\n\t * Max frame delta clamp passed to scheduled callbacks.\n\t */\n\tmaxDelta: CurrentWritable<number>;\n\t/**\n\t * Scheduler render mode (`always`, `on-demand`, `manual`).\n\t */\n\trenderMode: CurrentWritable<RenderMode>;\n\t/**\n\t * Global toggle for automatic rendering.\n\t */\n\tautoRender: CurrentWritable<boolean>;\n\t/**\n\t * Namespaced user context store shared within the canvas subtree.\n\t */\n\tuser: MotionGPUUserContext;\n\t/**\n\t * Marks current frame as invalidated.\n\t */\n\tinvalidate: () => void;\n\t/**\n\t * Requests one manual frame advance.\n\t */\n\tadvance: () => void;\n\t/**\n\t * Public scheduler API.\n\t */\n\tscheduler: MotionGPUScheduler;\n}\n\n/**\n * Vue injection key used to expose `FragCanvas` runtime state.\n */\nexport const motionGPUContextKey: InjectionKey<MotionGPUContext> = Symbol('motiongpu.context');\n\n/**\n * Registers the motiongpu context in the current Vue component tree.\n *\n * @param context - Context payload to provide.\n */\nexport function provideMotionGPUContext(context: MotionGPUContext): void {\n\tprovide(motionGPUContextKey, context);\n}\n\n/**\n * Returns the active motiongpu context.\n *\n * @returns Active context.\n * @throws {Error} When called outside `<FragCanvas>`.\n */\nexport function useMotionGPU(): MotionGPUContext {\n\tconst context = inject(motionGPUContextKey, null);\n\tif (!context) {\n\t\tthrow new Error('useMotionGPU must be used inside <FragCanvas>');\n\t}\n\n\treturn context;\n}\n"],"mappings":";;;;;AAwEA,IAAa,sBAAsD,OAAO,oBAAoB;;;;;;AAO9F,SAAgB,wBAAwB,SAAiC;AACxE,SAAQ,qBAAqB,QAAQ;;;;;;;;AAStC,SAAgB,eAAiC;CAChD,MAAM,UAAU,OAAO,qBAAqB,KAAK;AACjD,KAAI,CAAC,QACJ,OAAM,IAAI,MAAM,gDAAgD;AAGjE,QAAO"}

package/dist/vue/use-motiongpu-user-context.d.ts

@@ -0,0 +1,44 @@
+import type { CurrentReadable } from '../core/current-value.js';
+import { type MotionGPUUserNamespace } from './motiongpu-context.js';
+/**
+ * Internal shape of the user context store.
+ */
+type UserContextStore = Record<MotionGPUUserNamespace, unknown>;
+/**
+ * Controls how a namespaced user context value behaves when already present.
+ */
+export interface SetMotionGPUUserContextOptions {
+    /**
+     * Conflict strategy when namespace already exists:
+     * - `skip`: keep current value
+     * - `replace`: replace current value
+     * - `merge`: shallow merge object values, fallback to replace otherwise
+     *
+     * @default 'skip'
+     */
+    existing?: 'merge' | 'replace' | 'skip';
+    /**
+     * How function inputs should be interpreted:
+     * - `factory`: call function and store its return value
+     * - `value`: store function itself
+     *
+     * @default 'factory'
+     */
+    functionValue?: 'factory' | 'value';
+}
+/**
+ * Returns a read-only view of the entire motiongpu user context store.
+ */
+export declare function useMotionGPUUserContext<UC extends UserContextStore = UserContextStore>(): CurrentReadable<UC>;
+/**
+ * Reads a namespaced user context value as a reactive readable store.
+ */
+export declare function useMotionGPUUserContext<UC extends UserContextStore = UserContextStore, K extends keyof UC & MotionGPUUserNamespace = keyof UC & MotionGPUUserNamespace>(namespace: K): CurrentReadable<UC[K] | undefined>;
+/**
+ * Sets a namespaced user context value with explicit write semantics.
+ *
+ * Returns the effective value stored under the namespace.
+ */
+export declare function setMotionGPUUserContext<UCT = unknown>(namespace: MotionGPUUserNamespace, value: UCT | (() => UCT), options?: SetMotionGPUUserContextOptions): UCT | undefined;
+export {};
+//# sourceMappingURL=use-motiongpu-user-context.d.ts.map

package/dist/vue/use-motiongpu-user-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-motiongpu-user-context.d.ts","sourceRoot":"","sources":["../../src/lib/vue/use-motiongpu-user-context.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAgB,KAAK,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAEnF;;GAEG;AACH,KAAK,gBAAgB,GAAG,MAAM,CAAC,sBAAsB,EAAE,OAAO,CAAC,CAAC;AAOhE;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC9C;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;IACxC;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,SAAS,GAAG,OAAO,CAAC;CACpC;AASD;;GAEG;AACH,wBAAgB,uBAAuB,CACtC,EAAE,SAAS,gBAAgB,GAAG,gBAAgB,KAC1C,eAAe,CAAC,EAAE,CAAC,CAAC;AAEzB;;GAEG;AACH,wBAAgB,uBAAuB,CACtC,EAAE,SAAS,gBAAgB,GAAG,gBAAgB,EAC9C,CAAC,SAAS,MAAM,EAAE,GAAG,sBAAsB,GAAG,MAAM,EAAE,GAAG,sBAAsB,EAC9E,SAAS,EAAE,CAAC,GAAG,eAAe,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;AAwCpD;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,GAAG,GAAG,OAAO,EACpD,SAAS,EAAE,sBAAsB,EACjC,KAAK,EAAE,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,EACxB,OAAO,CAAC,EAAE,8BAA8B,GACtC,GAAG,GAAG,SAAS,CAuCjB"}

package/dist/vue/use-motiongpu-user-context.js

@@ -0,0 +1,76 @@
+import { useMotionGPU } from "./motiongpu-context.js";
+//#region src/lib/vue/use-motiongpu-user-context.ts
+/**
+* Checks whether a value is a non-array object suitable for shallow merge.
+*/
+function isObjectEntry(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Read-only user context composable:
+* - no args: returns full user context store
+* - namespace: returns namespaced store view
+*
+* @param namespace - Optional namespace key.
+*/
+function useMotionGPUUserContext(namespace) {
+	const userStore = useMotionGPU().user;
+	if (namespace === void 0) return {
+		get current() {
+			return userStore.current;
+		},
+		subscribe(run) {
+			return userStore.subscribe((context) => run(context));
+		}
+	};
+	return {
+		get current() {
+			return userStore.current[namespace];
+		},
+		subscribe(run) {
+			return userStore.subscribe((context) => run(context[namespace]));
+		}
+	};
+}
+/**
+* Sets a namespaced user context value with explicit write semantics.
+*
+* Returns the effective value stored under the namespace.
+*/
+function setMotionGPUUserContext(namespace, value, options) {
+	const userStore = useMotionGPU().user;
+	const mode = options?.existing ?? "skip";
+	const functionValueMode = options?.functionValue ?? "factory";
+	let resolvedValue;
+	userStore.update((context) => {
+		const hasExisting = namespace in context;
+		if (hasExisting && mode === "skip") {
+			resolvedValue = context[namespace];
+			return context;
+		}
+		const nextValue = typeof value === "function" && functionValueMode === "factory" ? value() : value;
+		if (hasExisting && mode === "merge") {
+			const currentValue = context[namespace];
+			if (isObjectEntry(currentValue) && isObjectEntry(nextValue)) {
+				resolvedValue = {
+					...currentValue,
+					...nextValue
+				};
+				return {
+					...context,
+					[namespace]: resolvedValue
+				};
+			}
+		}
+		resolvedValue = nextValue;
+		return {
+			...context,
+			[namespace]: nextValue
+		};
+	});
+	return resolvedValue;
+}
+//#endregion
+export { setMotionGPUUserContext, useMotionGPUUserContext };
+
+//# sourceMappingURL=use-motiongpu-user-context.js.map

package/dist/vue/use-motiongpu-user-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-motiongpu-user-context.js","names":[],"sources":["../../src/lib/vue/use-motiongpu-user-context.ts"],"sourcesContent":["import type { CurrentReadable } from '../core/current-value.js';\nimport { useMotionGPU, type MotionGPUUserNamespace } from './motiongpu-context.js';\n\n/**\n * Internal shape of the user context store.\n */\ntype UserContextStore = Record<MotionGPUUserNamespace, unknown>;\n\n/**\n * Object-like context payload used by merge semantics.\n */\ntype UserContextEntry = Record<string, unknown>;\n\n/**\n * Controls how a namespaced user context value behaves when already present.\n */\nexport interface SetMotionGPUUserContextOptions {\n\t/**\n\t * Conflict strategy when namespace already exists:\n\t * - `skip`: keep current value\n\t * - `replace`: replace current value\n\t * - `merge`: shallow merge object values, fallback to replace otherwise\n\t *\n\t * @default 'skip'\n\t */\n\texisting?: 'merge' | 'replace' | 'skip';\n\t/**\n\t * How function inputs should be interpreted:\n\t * - `factory`: call function and store its return value\n\t * - `value`: store function itself\n\t *\n\t * @default 'factory'\n\t */\n\tfunctionValue?: 'factory' | 'value';\n}\n\n/**\n * Checks whether a value is a non-array object suitable for shallow merge.\n */\nfunction isObjectEntry(value: unknown): value is UserContextEntry {\n\treturn typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\n/**\n * Returns a read-only view of the entire motiongpu user context store.\n */\nexport function useMotionGPUUserContext<\n\tUC extends UserContextStore = UserContextStore\n>(): CurrentReadable<UC>;\n\n/**\n * Reads a namespaced user context value as a reactive readable store.\n */\nexport function useMotionGPUUserContext<\n\tUC extends UserContextStore = UserContextStore,\n\tK extends keyof UC & MotionGPUUserNamespace = keyof UC & MotionGPUUserNamespace\n>(namespace: K): CurrentReadable<UC[K] | undefined>;\n\n/**\n * Read-only user context composable:\n * - no args: returns full user context store\n * - namespace: returns namespaced store view\n *\n * @param namespace - Optional namespace key.\n */\nexport function useMotionGPUUserContext<\n\tUC extends UserContextStore = UserContextStore,\n\tK extends keyof UC & MotionGPUUserNamespace = keyof UC & MotionGPUUserNamespace\n>(namespace?: K): CurrentReadable<UC> | CurrentReadable<UC[K] | undefined> {\n\tconst userStore = useMotionGPU().user;\n\n\tif (namespace === undefined) {\n\t\tconst allStore: CurrentReadable<UC> = {\n\t\t\tget current() {\n\t\t\t\treturn userStore.current as UC;\n\t\t\t},\n\t\t\tsubscribe(run) {\n\t\t\t\treturn userStore.subscribe((context) => run(context as UC));\n\t\t\t}\n\t\t};\n\n\t\treturn allStore;\n\t}\n\n\tconst scopedStore: CurrentReadable<UC[K] | undefined> = {\n\t\tget current() {\n\t\t\treturn userStore.current[namespace] as UC[K] | undefined;\n\t\t},\n\t\tsubscribe(run) {\n\t\t\treturn userStore.subscribe((context) => run(context[namespace] as UC[K] | undefined));\n\t\t}\n\t};\n\n\treturn scopedStore;\n}\n\n/**\n * Sets a namespaced user context value with explicit write semantics.\n *\n * Returns the effective value stored under the namespace.\n */\nexport function setMotionGPUUserContext<UCT = unknown>(\n\tnamespace: MotionGPUUserNamespace,\n\tvalue: UCT | (() => UCT),\n\toptions?: SetMotionGPUUserContextOptions\n): UCT | undefined {\n\tconst userStore = useMotionGPU().user;\n\tconst mode = options?.existing ?? 'skip';\n\tconst functionValueMode = options?.functionValue ?? 'factory';\n\tlet resolvedValue: UCT | undefined;\n\n\tuserStore.update((context) => {\n\t\tconst hasExisting = namespace in context;\n\t\tif (hasExisting && mode === 'skip') {\n\t\t\tresolvedValue = context[namespace] as UCT | undefined;\n\t\t\treturn context;\n\t\t}\n\n\t\tconst nextValue =\n\t\t\ttypeof value === 'function' && functionValueMode === 'factory'\n\t\t\t\t? (value as () => UCT)()\n\t\t\t\t: (value as UCT);\n\t\tif (hasExisting && mode === 'merge') {\n\t\t\tconst currentValue = context[namespace];\n\t\t\tif (isObjectEntry(currentValue) && isObjectEntry(nextValue)) {\n\t\t\t\tresolvedValue = {\n\t\t\t\t\t...currentValue,\n\t\t\t\t\t...nextValue\n\t\t\t\t} as UCT;\n\t\t\t\treturn {\n\t\t\t\t\t...context,\n\t\t\t\t\t[namespace]: resolvedValue\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\tresolvedValue = nextValue;\n\t\treturn {\n\t\t\t...context,\n\t\t\t[namespace]: nextValue\n\t\t};\n\t});\n\n\treturn resolvedValue;\n}\n"],"mappings":";;;;;AAuCA,SAAS,cAAc,OAA2C;AACjE,QAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,CAAC,MAAM,QAAQ,MAAM;;;;;;;;;AAyB5E,SAAgB,wBAGd,WAAyE;CAC1E,MAAM,YAAY,cAAc,CAAC;AAEjC,KAAI,cAAc,OAUjB,QATsC;EACrC,IAAI,UAAU;AACb,UAAO,UAAU;;EAElB,UAAU,KAAK;AACd,UAAO,UAAU,WAAW,YAAY,IAAI,QAAc,CAAC;;EAE5D;AAcF,QATwD;EACvD,IAAI,UAAU;AACb,UAAO,UAAU,QAAQ;;EAE1B,UAAU,KAAK;AACd,UAAO,UAAU,WAAW,YAAY,IAAI,QAAQ,WAAgC,CAAC;;EAEtF;;;;;;;AAUF,SAAgB,wBACf,WACA,OACA,SACkB;CAClB,MAAM,YAAY,cAAc,CAAC;CACjC,MAAM,OAAO,SAAS,YAAY;CAClC,MAAM,oBAAoB,SAAS,iBAAiB;CACpD,IAAI;AAEJ,WAAU,QAAQ,YAAY;EAC7B,MAAM,cAAc,aAAa;AACjC,MAAI,eAAe,SAAS,QAAQ;AACnC,mBAAgB,QAAQ;AACxB,UAAO;;EAGR,MAAM,YACL,OAAO,UAAU,cAAc,sBAAsB,YACjD,OAAqB,GACrB;AACL,MAAI,eAAe,SAAS,SAAS;GACpC,MAAM,eAAe,QAAQ;AAC7B,OAAI,cAAc,aAAa,IAAI,cAAc,UAAU,EAAE;AAC5D,oBAAgB;KACf,GAAG;KACH,GAAG;KACH;AACD,WAAO;KACN,GAAG;MACF,YAAY;KACb;;;AAIH,kBAAgB;AAChB,SAAO;GACN,GAAG;IACF,YAAY;GACb;GACA;AAEF,QAAO"}

package/dist/vue/use-pointer.d.ts

@@ -0,0 +1,94 @@
+import { type CurrentReadable } from '../core/current-value.js';
+import { type PointerClick, type PointerFrameRequestMode, type PointerState } from '../core/pointer.js';
+export type { PointerClick, PointerFrameRequestMode, PointerKind, PointerPoint, PointerState } from '../core/pointer.js';
+/**
+ * Configuration for pointer input handling in `usePointer`.
+ */
+export interface UsePointerOptions {
+    /**
+     * Enables pointer listeners.
+     *
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Frame wake-up strategy for pointer-driven state changes.
+     *
+     * @default 'auto'
+     */
+    requestFrame?: PointerFrameRequestMode;
+    /**
+     * Requests pointer capture on pointer down.
+     *
+     * @default true
+     */
+    capturePointer?: boolean;
+    /**
+     * Tracks pointer move/up outside canvas while pointer is pressed.
+     *
+     * @default true
+     */
+    trackWhilePressedOutsideCanvas?: boolean;
+    /**
+     * Enables click/tap synthesis on pointer up.
+     *
+     * @default true
+     */
+    clickEnabled?: boolean;
+    /**
+     * Maximum press duration to consider pointer up a click (milliseconds).
+     *
+     * @default 350
+     */
+    clickMaxDurationMs?: number;
+    /**
+     * Maximum pointer travel from down to up to consider pointer up a click (pixels).
+     *
+     * @default 8
+     */
+    clickMaxMovePx?: number;
+    /**
+     * Allowed pointer buttons for click synthesis.
+     *
+     * @default [0]
+     */
+    clickButtons?: number[];
+    /**
+     * Called after pointer move state update.
+     */
+    onMove?: (state: PointerState, event: PointerEvent) => void;
+    /**
+     * Called after pointer down state update.
+     */
+    onDown?: (state: PointerState, event: PointerEvent) => void;
+    /**
+     * Called after pointer up/cancel state update.
+     */
+    onUp?: (state: PointerState, event: PointerEvent) => void;
+    /**
+     * Called when click/tap is synthesized.
+     */
+    onClick?: (click: PointerClick, state: PointerState, event: PointerEvent) => void;
+}
+/**
+ * Reactive state returned by `usePointer`.
+ */
+export interface UsePointerResult {
+    /**
+     * Current pointer state.
+     */
+    state: CurrentReadable<PointerState>;
+    /**
+     * Last synthesized click/tap event.
+     */
+    lastClick: CurrentReadable<PointerClick | null>;
+    /**
+     * Clears last click snapshot.
+     */
+    resetClick: () => void;
+}
+/**
+ * Tracks normalized pointer coordinates and click/tap snapshots for the active `FragCanvas`.
+ */
+export declare function usePointer(options?: UsePointerOptions): UsePointerResult;
+//# sourceMappingURL=use-pointer.d.ts.map

package/dist/vue/use-pointer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-pointer.d.ts","sourceRoot":"","sources":["../../src/lib/vue/use-pointer.ts"],"names":[],"mappings":"AACA,OAAO,EAEN,KAAK,eAAe,EACpB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAMN,KAAK,YAAY,EACjB,KAAK,uBAAuB,EAC5B,KAAK,YAAY,EAEjB,MAAM,oBAAoB,CAAC;AAG5B,YAAY,EACX,YAAY,EACZ,uBAAuB,EACvB,WAAW,EACX,YAAY,EACZ,YAAY,EACZ,MAAM,oBAAoB,CAAC;AAE5B;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,YAAY,CAAC,EAAE,uBAAuB,CAAC;IACvC;;;;OAIG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;OAIG;IACH,8BAA8B,CAAC,EAAE,OAAO,CAAC;IACzC;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;;OAIG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B;;;;OAIG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB;;OAEG;IACH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IAC5D;;OAEG;IACH,MAAM,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IAC5D;;OAEG;IACH,IAAI,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;IAC1D;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,KAAK,IAAI,CAAC;CAClF;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAChC;;OAEG;IACH,KAAK,EAAE,eAAe,CAAC,YAAY,CAAC,CAAC;IACrC;;OAEG;IACH,SAAS,EAAE,eAAe,CAAC,YAAY,GAAG,IAAI,CAAC,CAAC;IAChD;;OAEG;IACH,UAAU,EAAE,MAAM,IAAI,CAAC;CACvB;AA0CD;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,gBAAgB,CAoW5E"}

package/dist/vue/use-pointer.js

@@ -0,0 +1,298 @@
+import { createCurrentWritable } from "../core/current-value.js";
+import { createInitialPointerState, getPointerCoordinates, getPointerNowSeconds, normalizePointerKind, resolvePointerFrameRequestMode } from "../core/pointer.js";
+import { useMotionGPU } from "./motiongpu-context.js";
+import { onBeforeUnmount, onMounted } from "vue";
+//#region src/lib/vue/use-pointer.ts
+/**
+* Normalizes click button configuration with a primary-button fallback.
+*/
+function normalizeClickButtons(buttons) {
+	const source = buttons && buttons.length > 0 ? buttons : [0];
+	return new Set(source);
+}
+/**
+* Resolves a valid click duration threshold in milliseconds.
+*/
+function resolveClickMaxDurationMs(value) {
+	if (typeof value !== "number" || Number.isNaN(value) || value <= 0) return 350;
+	return value;
+}
+/**
+* Resolves a valid click travel threshold in pixels.
+*/
+function resolveClickMaxMovePx(value) {
+	if (typeof value !== "number" || Number.isNaN(value) || value < 0) return 8;
+	return value;
+}
+/**
+* Tracks normalized pointer coordinates and click/tap snapshots for the active `FragCanvas`.
+*/
+function usePointer(options = {}) {
+	const motiongpu = useMotionGPU();
+	const pointerState = createCurrentWritable(createInitialPointerState());
+	const lastClick = createCurrentWritable(null);
+	const enabled = options.enabled ?? true;
+	const requestFrameMode = options.requestFrame ?? "auto";
+	const capturePointer = options.capturePointer ?? true;
+	const trackOutside = options.trackWhilePressedOutsideCanvas ?? true;
+	const clickEnabled = options.clickEnabled ?? true;
+	const clickMaxDurationMs = resolveClickMaxDurationMs(options.clickMaxDurationMs);
+	const clickMaxMovePx = resolveClickMaxMovePx(options.clickMaxMovePx);
+	const clickButtons = normalizeClickButtons(options.clickButtons);
+	let activePointerId = null;
+	let downSnapshot = null;
+	let clickCounter = 0;
+	let previousPx = null;
+	let previousUv = null;
+	let previousTimeSeconds = 0;
+	let cleanup = null;
+	const requestFrame = () => {
+		const mode = resolvePointerFrameRequestMode(requestFrameMode, motiongpu.renderMode.current);
+		if (mode === "invalidate") {
+			motiongpu.invalidate();
+			return;
+		}
+		if (mode === "advance") motiongpu.advance();
+	};
+	/**
+	* Commits a full pointer state snapshot with computed delta and velocity vectors.
+	*/
+	const updatePointerState = (input) => {
+		const nowSeconds = getPointerNowSeconds();
+		const dt = previousTimeSeconds > 0 ? Math.max(nowSeconds - previousTimeSeconds, 1e-6) : 0;
+		const deltaPx = input.resetDelta || !previousPx ? [0, 0] : [input.point.px[0] - previousPx[0], input.point.px[1] - previousPx[1]];
+		const deltaUv = input.resetDelta || !previousUv ? [0, 0] : [input.point.uv[0] - previousUv[0], input.point.uv[1] - previousUv[1]];
+		const velocityPx = dt > 0 ? [deltaPx[0] / dt, deltaPx[1] / dt] : [0, 0];
+		const velocityUv = dt > 0 ? [deltaUv[0] / dt, deltaUv[1] / dt] : [0, 0];
+		const nextState = {
+			px: input.point.px,
+			uv: input.point.uv,
+			ndc: input.point.ndc,
+			inside: input.inside,
+			pressed: input.pressed,
+			dragging: input.dragging,
+			pointerType: input.pointerType,
+			pointerId: input.pointerId,
+			button: input.button,
+			buttons: input.buttons,
+			time: nowSeconds,
+			downPx: input.downPx,
+			downUv: input.downUv,
+			deltaPx,
+			deltaUv,
+			velocityPx,
+			velocityUv
+		};
+		pointerState.set(nextState);
+		previousPx = input.point.px;
+		previousUv = input.point.uv;
+		previousTimeSeconds = nowSeconds;
+		requestFrame();
+		return nextState;
+	};
+	/**
+	* Updates only the `inside` flag while keeping the latest pointer coordinates.
+	*/
+	const updateInsideState = (inside) => {
+		const nextState = {
+			...pointerState.current,
+			inside,
+			time: getPointerNowSeconds(),
+			deltaPx: [0, 0],
+			deltaUv: [0, 0],
+			velocityPx: [0, 0],
+			velocityUv: [0, 0]
+		};
+		pointerState.set(nextState);
+		requestFrame();
+		return nextState;
+	};
+	/**
+	* Checks whether an event belongs to the active tracked pointer.
+	*/
+	const isTrackedPointer = (event) => activePointerId === null || event.pointerId === activePointerId;
+	const attachListeners = () => {
+		if (!enabled) return;
+		const canvas = motiongpu.canvas;
+		if (!canvas) return;
+		const handlePointerDown = (event) => {
+			const point = getPointerCoordinates(event.clientX, event.clientY, canvas.getBoundingClientRect());
+			const pointerType = normalizePointerKind(event.pointerType);
+			activePointerId = event.pointerId;
+			downSnapshot = {
+				pointerId: event.pointerId,
+				pointerType,
+				button: event.button,
+				timeMs: getPointerNowSeconds() * 1e3,
+				px: point.px,
+				uv: point.uv,
+				inside: point.inside
+			};
+			if (capturePointer) try {
+				canvas.setPointerCapture(event.pointerId);
+			} catch {}
+			const nextState = updatePointerState({
+				point,
+				inside: point.inside,
+				pressed: true,
+				dragging: false,
+				pointerType,
+				pointerId: event.pointerId,
+				button: event.button,
+				buttons: event.buttons,
+				downPx: point.px,
+				downUv: point.uv,
+				resetDelta: true
+			});
+			options.onDown?.(nextState, event);
+		};
+		const handleMove = (event) => {
+			if (!isTrackedPointer(event)) return;
+			const point = getPointerCoordinates(event.clientX, event.clientY, canvas.getBoundingClientRect());
+			const pressed = activePointerId !== null && event.pointerId === activePointerId;
+			const downPx = pressed ? downSnapshot?.px ?? point.px : null;
+			const downUv = pressed ? downSnapshot?.uv ?? point.uv : null;
+			let dragging = false;
+			if (pressed && downPx) {
+				const dx = point.px[0] - downPx[0];
+				const dy = point.px[1] - downPx[1];
+				dragging = Math.hypot(dx, dy) > 0;
+			}
+			const nextState = updatePointerState({
+				point,
+				inside: point.inside,
+				pressed,
+				dragging,
+				pointerType: normalizePointerKind(event.pointerType),
+				pointerId: event.pointerId,
+				button: pressed ? downSnapshot?.button ?? event.button : null,
+				buttons: event.buttons,
+				downPx,
+				downUv
+			});
+			options.onMove?.(nextState, event);
+		};
+		const handleWindowMove = (event) => {
+			if (!trackOutside || activePointerId === null || event.pointerId !== activePointerId) return;
+			const point = getPointerCoordinates(event.clientX, event.clientY, canvas.getBoundingClientRect());
+			if (point.inside) return;
+			const downPx = downSnapshot?.px ?? point.px;
+			const downUv = downSnapshot?.uv ?? point.uv;
+			const dx = point.px[0] - downPx[0];
+			const dy = point.px[1] - downPx[1];
+			const nextState = updatePointerState({
+				point,
+				inside: false,
+				pressed: true,
+				dragging: Math.hypot(dx, dy) > 0,
+				pointerType: downSnapshot?.pointerType ?? normalizePointerKind(event.pointerType),
+				pointerId: event.pointerId,
+				button: downSnapshot?.button ?? event.button,
+				buttons: event.buttons,
+				downPx,
+				downUv
+			});
+			options.onMove?.(nextState, event);
+		};
+		const releasePointer = (event, emitClick) => {
+			if (activePointerId === null || event.pointerId !== activePointerId) return;
+			const point = getPointerCoordinates(event.clientX, event.clientY, canvas.getBoundingClientRect());
+			const pointerType = downSnapshot?.pointerType ?? normalizePointerKind(event.pointerType);
+			const previous = downSnapshot;
+			const nextState = updatePointerState({
+				point,
+				inside: point.inside,
+				pressed: false,
+				dragging: false,
+				pointerType,
+				pointerId: null,
+				button: null,
+				buttons: event.buttons,
+				downPx: null,
+				downUv: null
+			});
+			options.onUp?.(nextState, event);
+			if (capturePointer && canvas.hasPointerCapture(event.pointerId)) try {
+				canvas.releasePointerCapture(event.pointerId);
+			} catch {}
+			if (emitClick && clickEnabled && previous && clickButtons.has(previous.button)) {
+				const durationMs = getPointerNowSeconds() * 1e3 - previous.timeMs;
+				const dx = point.px[0] - previous.px[0];
+				const dy = point.px[1] - previous.px[1];
+				const moveDistance = Math.hypot(dx, dy);
+				if (previous.inside && point.inside && durationMs <= clickMaxDurationMs && moveDistance <= clickMaxMovePx) {
+					clickCounter += 1;
+					const click = {
+						id: clickCounter,
+						time: getPointerNowSeconds(),
+						pointerType,
+						pointerId: event.pointerId,
+						button: previous.button,
+						modifiers: {
+							alt: event.altKey,
+							ctrl: event.ctrlKey,
+							shift: event.shiftKey,
+							meta: event.metaKey
+						},
+						px: point.px,
+						uv: point.uv,
+						ndc: point.ndc
+					};
+					lastClick.set(click);
+					options.onClick?.(click, nextState, event);
+					requestFrame();
+				}
+			}
+			activePointerId = null;
+			downSnapshot = null;
+		};
+		const handlePointerUp = (event) => {
+			releasePointer(event, true);
+		};
+		const handlePointerCancel = (event) => {
+			releasePointer(event, false);
+		};
+		const handlePointerLeave = () => {
+			if (activePointerId !== null) return;
+			updateInsideState(false);
+		};
+		canvas.addEventListener("pointerdown", handlePointerDown);
+		canvas.addEventListener("pointermove", handleMove);
+		canvas.addEventListener("pointerup", handlePointerUp);
+		canvas.addEventListener("pointercancel", handlePointerCancel);
+		canvas.addEventListener("pointerleave", handlePointerLeave);
+		if (trackOutside) {
+			window.addEventListener("pointermove", handleWindowMove);
+			window.addEventListener("pointerup", handlePointerUp);
+			window.addEventListener("pointercancel", handlePointerCancel);
+		}
+		cleanup = () => {
+			canvas.removeEventListener("pointerdown", handlePointerDown);
+			canvas.removeEventListener("pointermove", handleMove);
+			canvas.removeEventListener("pointerup", handlePointerUp);
+			canvas.removeEventListener("pointercancel", handlePointerCancel);
+			canvas.removeEventListener("pointerleave", handlePointerLeave);
+			if (trackOutside) {
+				window.removeEventListener("pointermove", handleWindowMove);
+				window.removeEventListener("pointerup", handlePointerUp);
+				window.removeEventListener("pointercancel", handlePointerCancel);
+			}
+		};
+	};
+	onMounted(attachListeners);
+	onBeforeUnmount(() => {
+		cleanup?.();
+		cleanup = null;
+	});
+	return {
+		state: pointerState,
+		lastClick,
+		resetClick: () => {
+			lastClick.set(null);
+		}
+	};
+}
+//#endregion
+export { usePointer };
+
+//# sourceMappingURL=use-pointer.js.map