@codexo/exojs-react 0.15.2 → 0.16.0

package/dist/esm/useScene.js

@@ -1,83 +1,76 @@
-import { ApplicationStatus } from '@codexo/exojs';
-import { useState, useEffect } from 'react';
-import { useExoApp } from './useExoApp.js';
+import { useExoApp } from "./useExoApp.js";
+import { useEffect, useRef, useState } from "react";
+import { ApplicationState } from "@codexo/exojs";
 
+//#region src/useScene.ts
 /**
- * Creates an instance of `SceneClass`, activates it on the ExoJS
- * {@link Application}, and returns it once the scene is live.
- *
- * On first call (engine not yet started) this hook calls `app.start(scene)`,
- * which initializes the render backend and begins the per-frame loop. On
- * subsequent dep-change remounts it calls `app.scene.setScene(scene)` to
- * switch scenes without restarting the engine.
- *
- * The scene is cleared (`setScene(null)`) when the component unmounts or
- * when `deps` change — mirroring `useEffect` semantics.
- *
- * A failure in `app.start()`/`app.scene.setScene()` (e.g. a scene's `onLoad`
- * rejects) is caught and routed to {@link Application.onError} rather than
- * left as an unhandled promise rejection — subscribe via
- * `app.onError.add(...)` or the {@link import('./ExoCanvas').ExoCanvas}
- * `onError` prop to observe it.
- *
- * @param SceneClass - Constructor for the scene to instantiate.
- * @param deps - Extra deps that trigger scene replacement when changed, in
- *   addition to the stable `app` reference (same semantics as `useEffect`).
- * @returns The active scene instance, or `null` while it is loading.
- *
- * @example
- * ```tsx
- * function GameScreen() {
- *   const scene = useScene(MyGameScene);
- *   if (!scene) return null;
- *   return <ScoreHud scene={scene} />;
- * }
- * ```
- */
-// eslint-disable-next-line @typescript-eslint/naming-convention
-function useScene(SceneClass, deps = []) {
-    const app = useExoApp();
-    const [scene, setScene] = useState(null);
-    useEffect(() => {
-        let cancelled = false;
-        const s = new SceneClass();
-        const apply = async () => {
-            try {
-                if (app.status === ApplicationStatus.Stopped) {
-                    // First activation — initialize the backend and start the frame loop.
-                    await app.start(s);
-                }
-                else {
-                    // Engine already running — switch scenes without restarting.
-                    await app.scene.setScene(s);
-                }
-                if (!cancelled) {
-                    setScene(s);
-                }
-            }
-            catch (error) {
-                // Route to Application.onError instead of leaving an unhandled
-                // rejection — app.start()/setScene() reject rather than dispatching
-                // onError themselves.
-                app.onError.dispatch(error instanceof Error ? error : new Error(String(error)));
-            }
-        };
-        void apply();
-        return () => {
-            cancelled = true;
-            setScene(null);
-            // Best-effort scene clear; the Application.destroy() called by
-            // ExoCanvas cleanup will also handle any remaining active scene.
-            void app.scene.setScene(null).catch((error) => {
-                app.onError.dispatch(error instanceof Error ? error : new Error(String(error)));
-            });
-        };
-        // SceneClass is intentionally excluded from deps: a new class reference
-        // (e.g. inline arrow class) on every render would recreate the scene
-        // each frame. Pass an explicit deps array to react to changes.
-    }, [app, ...deps]);
-    return scene;
-}
+* Activates `SceneClass` on the ExoJS {@link Application} and returns the
+* resulting instance once it is live. `SceneClass` must be registered in
+* `ApplicationOptions.scenes` (passed to {@link import('./useExoApplication').useExoApplication}
+* / {@link import('./ExoCanvas').ExoCanvas}) - unregistered targets reject in
+* development builds.
+*
+* On first call (engine not yet started) this hook calls `app.start(SceneClass)`,
+* which initializes the render backend and begins the per-frame loop. On
+* subsequent dep-change remounts it calls `app.scenes.change(SceneClass)` to
+* switch scenes without restarting the engine, constructing a fresh instance.
+*
+* Effects that run while startup is still in flight - React StrictMode
+* double-mounts every effect in development - join that `app.start()` call
+* instead of racing a second navigation against it, and only activate
+* `SceneClass` afterwards if startup did not already leave it active. A
+* StrictMode double mount therefore activates the scene exactly once.
+*
+* A failure in `app.start()`/`app.scenes.change()` (e.g. a scene's `load()`
+* rejects) is caught and routed to {@link Application.onError} rather than
+* left as an unhandled promise rejection - subscribe via
+* `app.onError.add(...)` or the {@link import('./ExoCanvas').ExoCanvas}
+* `onError` prop to observe it.
+*
+* @param SceneClass - Constructor for the scene to activate.
+* @param deps - Extra deps that trigger scene replacement when changed, in
+*   addition to the stable `app` reference (same semantics as `useEffect`).
+* @returns The active scene instance, or `null` while it is loading.
+*
+* @example
+* ```tsx
+* function GameScreen() {
+*   const scene = useScene(MyGameScene);
+*   if (!scene) return null;
+*   return <ScoreHud scene={scene} />;
+* }
+* ```
+*/
+const useScene = (SceneClass, deps = []) => {
+	const app = useExoApp();
+	const [scene, setScene] = useState(null);
+	const generationRef = useRef(0);
+	useEffect(() => {
+		let cancelled = false;
+		const generation = ++generationRef.current;
+		const isStale = () => cancelled || generationRef.current !== generation;
+		const target = SceneClass;
+		const apply = async () => {
+			try {
+				if (app.state === ApplicationState.Stopped || app.state === ApplicationState.Loading) {
+					await app.start(target);
+					if (isStale()) return;
+					if (!(app.scenes.currentScene instanceof SceneClass)) await app.scenes.change(target);
+				} else await app.scenes.change(target);
+				if (!isStale()) setScene(app.scenes.currentScene);
+			} catch (error) {
+				if (!isStale()) app.onError.dispatch(error instanceof Error ? error : new Error(String(error)));
+			}
+		};
+		apply();
+		return () => {
+			cancelled = true;
+			setScene(null);
+		};
+	}, [app, ...deps]);
+	return scene;
+};
 
+//#endregion
 export { useScene };
-//# sourceMappingURL=useScene.js.map
+//# sourceMappingURL=useScene.js.map

package/dist/esm/useScene.js.map

@@ -1 +1 @@
-{"version":3,"file":"useScene.js","sources":["../../../src/useScene.ts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BG;AACH;SACgB,QAAQ,CAAkB,UAAuB,EAAE,OAAuB,EAAE,EAAA;AAC1F,IAAA,MAAM,GAAG,GAAG,SAAS,EAAE;IACvB,MAAM,CAAC,KAAK,EAAE,QAAQ,CAAC,GAAG,QAAQ,CAAW,IAAI,CAAC;IAElD,SAAS,CAAC,MAAK;QACb,IAAI,SAAS,GAAG,KAAK;AACrB,QAAA,MAAM,CAAC,GAAG,IAAI,UAAU,EAAE;AAE1B,QAAA,MAAM,KAAK,GAAG,YAA0B;AACtC,YAAA,IAAI;gBACF,IAAI,GAAG,CAAC,MAAM,KAAK,iBAAiB,CAAC,OAAO,EAAE;;AAE5C,oBAAA,MAAM,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;gBACpB;qBAAO;;oBAEL,MAAM,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC;gBAC7B;gBAEA,IAAI,CAAC,SAAS,EAAE;oBACd,QAAQ,CAAC,CAAC,CAAC;gBACb;YACF;YAAE,OAAO,KAAK,EAAE;;;;gBAId,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,YAAY,KAAK,GAAG,KAAK,GAAG,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;YACjF;AACF,QAAA,CAAC;QAED,KAAK,KAAK,EAAE;AAEZ,QAAA,OAAO,MAAK;YACV,SAAS,GAAG,IAAI;YAChB,QAAQ,CAAC,IAAI,CAAC;;;AAGd,YAAA,KAAK,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,KAAc,KAAI;gBACrD,GAAG,CAAC,OAAO,CAAC,QAAQ,CAAC,KAAK,YAAY,KAAK,GAAG,KAAK,GAAG,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;AACjF,YAAA,CAAC,CAAC;AACJ,QAAA,CAAC;;;;IAIH,CAAC,EAAE,CAAC,GAAG,EAAE,GAAG,IAAI,CAAC,CAAC;AAElB,IAAA,OAAO,KAAK;AACd;;;;"}
+{"version":3,"file":"useScene.js","names":[],"sources":["../../src/useScene.ts"],"sourcesContent":["import { ApplicationState, type Scene, type SceneConstructor } from '@codexo/exojs';\nimport { type DependencyList, useEffect, useRef, useState } from 'react';\n\nimport { useExoApp } from './useExoApp';\n\n/**\n * Activates `SceneClass` on the ExoJS {@link Application} and returns the\n * resulting instance once it is live. `SceneClass` must be registered in\n * `ApplicationOptions.scenes` (passed to {@link import('./useExoApplication').useExoApplication}\n * / {@link import('./ExoCanvas').ExoCanvas}) - unregistered targets reject in\n * development builds.\n *\n * On first call (engine not yet started) this hook calls `app.start(SceneClass)`,\n * which initializes the render backend and begins the per-frame loop. On\n * subsequent dep-change remounts it calls `app.scenes.change(SceneClass)` to\n * switch scenes without restarting the engine, constructing a fresh instance.\n *\n * Effects that run while startup is still in flight - React StrictMode\n * double-mounts every effect in development - join that `app.start()` call\n * instead of racing a second navigation against it, and only activate\n * `SceneClass` afterwards if startup did not already leave it active. A\n * StrictMode double mount therefore activates the scene exactly once.\n *\n * A failure in `app.start()`/`app.scenes.change()` (e.g. a scene's `load()`\n * rejects) is caught and routed to {@link Application.onError} rather than\n * left as an unhandled promise rejection - subscribe via\n * `app.onError.add(...)` or the {@link import('./ExoCanvas').ExoCanvas}\n * `onError` prop to observe it.\n *\n * @param SceneClass - Constructor for the scene to activate.\n * @param deps - Extra deps that trigger scene replacement when changed, in\n *   addition to the stable `app` reference (same semantics as `useEffect`).\n * @returns The active scene instance, or `null` while it is loading.\n *\n * @example\n * ```tsx\n * function GameScreen() {\n *   const scene = useScene(MyGameScene);\n *   if (!scene) return null;\n *   return <ScoreHud scene={scene} />;\n * }\n * ```\n */\nexport const useScene = <T extends Scene>(SceneClass: new () => T, deps: DependencyList = []): T | null => {\n  const app = useExoApp();\n  const [scene, setScene] = useState<T | null>(null);\n  // Bumped on every effect run so an async `apply()` can tell whether a newer\n  // run has since taken over - the flag below only covers a run whose own\n  // cleanup has fired.\n  const generationRef = useRef(0);\n\n  useEffect(() => {\n    let cancelled = false;\n    const generation = ++generationRef.current;\n    // Only the newest, still-mounted run may touch component/app state: an\n    // earlier one's activation result is no longer what the component asked\n    // for, and neither is its failure.\n    const isStale = (): boolean => cancelled || generationRef.current !== generation;\n    // This hook's contract has always been zero-arg activation only (no data\n    // parameter) - `T extends Scene` (Data defaults to void), but that generic\n    // `T` can't be distributed through the navigation call's conditional types\n    // (InferSceneData/ChangeSceneArgs) inside this function body, so it's pinned\n    // to its concrete void-data instantiation here.\n    const target = SceneClass as SceneConstructor;\n\n    const apply = async (): Promise<void> => {\n      try {\n        if (app.state === ApplicationState.Stopped || app.state === ApplicationState.Loading) {\n          // Stopped: first activation, which initializes the backend and starts\n          // the frame loop. Loading: an earlier effect's `start()` is still in\n          // flight - including its own initial scene navigation, which\n          // `scenes.change()` would collide with (navigation never queues, it\n          // rejects). `start()` joins that in-flight run instead, ignoring the\n          // target passed here.\n          await app.start(target);\n\n          if (isStale()) {\n            return;\n          }\n\n          // Startup activates its own target, which is this one whenever the\n          // joined `start()` came from an effect for the same scene (the\n          // StrictMode double-mount case) - activating again would needlessly\n          // tear the scene down and rebuild it. A `start()` that targeted a\n          // different scene, or none at all, still needs the switch.\n          if (!(app.scenes.currentScene instanceof SceneClass)) {\n            await app.scenes.change(target);\n          }\n        } else {\n          // The engine is already running: a scene switch without a restart.\n          await app.scenes.change(target);\n        }\n\n        if (!isStale()) {\n          setScene(app.scenes.currentScene as T);\n        }\n      } catch (error) {\n        // Route to Application.onError instead of leaving an unhandled\n        // rejection - app.start()/change() reject rather than dispatching\n        // onError themselves. A superseded run stays silent: its failure is no\n        // longer this component's state, exactly like its success.\n        if (!isStale()) {\n          app.onError.dispatch(error instanceof Error ? error : new Error(String(error)));\n        }\n      }\n    };\n\n    void apply();\n\n    return () => {\n      cancelled = true;\n      setScene(null);\n      // No public API switches the director back to scene-less mid-lifetime\n      // (navigation always targets a registered\n      // constructor). Application.destroy() (called by ExoCanvas cleanup)\n      // tears down whatever scene is still active.\n    };\n    // SceneClass is intentionally excluded from deps: a new class reference\n    // (e.g. inline arrow class) on every render would recreate the scene\n    // each frame. Pass an explicit deps array to react to changes - which is\n    // also why the spread is here and why the lint rule can't verify this list.\n    // eslint-disable-next-line react-hooks/exhaustive-deps\n  }, [app, ...deps]);\n\n  return scene;\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2CA,MAAa,YAA6B,YAAyB,OAAuB,CAAC,MAAgB;CACzG,MAAM,MAAM,UAAU;CACtB,MAAM,CAAC,OAAO,YAAY,SAAmB,IAAI;CAIjD,MAAM,gBAAgB,OAAO,CAAC;CAE9B,gBAAgB;EACd,IAAI,YAAY;EAChB,MAAM,aAAa,EAAE,cAAc;EAInC,MAAM,gBAAyB,aAAa,cAAc,YAAY;EAMtE,MAAM,SAAS;EAEf,MAAM,QAAQ,YAA2B;GACvC,IAAI;IACF,IAAI,IAAI,UAAU,iBAAiB,WAAW,IAAI,UAAU,iBAAiB,SAAS;KAOpF,MAAM,IAAI,MAAM,MAAM;KAEtB,IAAI,QAAQ,GACV;KAQF,IAAI,EAAE,IAAI,OAAO,wBAAwB,aACvC,MAAM,IAAI,OAAO,OAAO,MAAM;IAElC,OAEE,MAAM,IAAI,OAAO,OAAO,MAAM;IAGhC,IAAI,CAAC,QAAQ,GACX,SAAS,IAAI,OAAO,YAAiB;GAEzC,SAAS,OAAO;IAKd,IAAI,CAAC,QAAQ,GACX,IAAI,QAAQ,SAAS,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,KAAK,CAAC,CAAC;GAElF;EACF;EAEA,AAAK,MAAM;EAEX,aAAa;GACX,YAAY;GACZ,SAAS,IAAI;EAKf;CAMF,GAAG,CAAC,KAAK,GAAG,IAAI,CAAC;CAEjB,OAAO;AACT"}

package/dist/esm/useSignal.d.ts

@@ -5,7 +5,7 @@ import type { Signal } from '@codexo/exojs';
  * Built on `useSyncExternalStore`, so reads stay tear-free under concurrent
  * rendering.
  *
- * The signal itself is only used to know *when* to re-read — `getSnapshot` is
+ * The signal itself is only used to know *when* to re-read - `getSnapshot` is
  * responsible for producing the actual value (usually a getter on the engine
  * object the signal lives on).
  *
@@ -20,9 +20,10 @@ import type { Signal } from '@codexo/exojs';
  * ```
  *
  * @param signal - The signal to subscribe to. `null`/`undefined` is accepted
- *   (e.g. before an `Application` exists) — the hook simply does not subscribe
+ *   (e.g. before an `Application` exists) - the hook simply does not subscribe
  *   to anything and `getSnapshot` still runs on every render.
  * @param getSnapshot - Reads the current value. Called on mount and again after
  *   every dispatch of `signal`.
  */
-export declare function useSignal<Args extends unknown[], T>(signal: Signal<Args> | null | undefined, getSnapshot: () => T): T;
+export declare const useSignal: <Args extends unknown[], T>(signal: Signal<Args> | null | undefined, getSnapshot: () => T) => T;
+//# sourceMappingURL=useSignal.d.ts.map

package/dist/esm/useSignal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSignal.d.ts","sourceRoot":"","sources":["../../src/useSignal.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AAG5C;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,SAAS,GAAI,IAAI,SAAS,OAAO,EAAE,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,GAAG,SAAS,EAAE,aAAa,MAAM,CAAC,KAAG,CAoBpH,CAAC"}

package/dist/esm/useSignal.js

@@ -1,45 +1,43 @@
-import { useCallback, useSyncExternalStore } from 'react';
+import { useCallback, useSyncExternalStore } from "react";
 
+//#region src/useSignal.ts
 /**
- * Subscribes to an ExoJS {@link Signal} and returns the latest value computed by
- * `getSnapshot`, re-rendering the component every time the signal dispatches.
- * Built on `useSyncExternalStore`, so reads stay tear-free under concurrent
- * rendering.
- *
- * The signal itself is only used to know *when* to re-read — `getSnapshot` is
- * responsible for producing the actual value (usually a getter on the engine
- * object the signal lives on).
- *
- * @example
- * ```tsx
- * function FrameCounter() {
- *   const app = useExoApp();
- *   // Re-renders on every `onFrame` dispatch (i.e. every engine frame).
- *   const frameCount = useSignal(app.onFrame, () => app.frameCount);
- *   return <span>Frame: {frameCount}</span>;
- * }
- * ```
- *
- * @param signal - The signal to subscribe to. `null`/`undefined` is accepted
- *   (e.g. before an `Application` exists) — the hook simply does not subscribe
- *   to anything and `getSnapshot` still runs on every render.
- * @param getSnapshot - Reads the current value. Called on mount and again after
- *   every dispatch of `signal`.
- */
-function useSignal(signal, getSnapshot) {
-    const subscribe = useCallback((onStoreChange) => {
-        if (!signal) {
-            // No signal to subscribe to (e.g. before an Application exists) — nothing to unsubscribe either.
-            // eslint-disable-next-line @typescript-eslint/no-empty-function -- intentional no-op unsubscribe
-            return () => { };
-        }
-        signal.add(onStoreChange);
-        return () => {
-            signal.remove(onStoreChange);
-        };
-    }, [signal]);
-    return useSyncExternalStore(subscribe, getSnapshot);
-}
+* Subscribes to an ExoJS {@link Signal} and returns the latest value computed by
+* `getSnapshot`, re-rendering the component every time the signal dispatches.
+* Built on `useSyncExternalStore`, so reads stay tear-free under concurrent
+* rendering.
+*
+* The signal itself is only used to know *when* to re-read - `getSnapshot` is
+* responsible for producing the actual value (usually a getter on the engine
+* object the signal lives on).
+*
+* @example
+* ```tsx
+* function FrameCounter() {
+*   const app = useExoApp();
+*   // Re-renders on every `onFrame` dispatch (i.e. every engine frame).
+*   const frameCount = useSignal(app.onFrame, () => app.frameCount);
+*   return <span>Frame: {frameCount}</span>;
+* }
+* ```
+*
+* @param signal - The signal to subscribe to. `null`/`undefined` is accepted
+*   (e.g. before an `Application` exists) - the hook simply does not subscribe
+*   to anything and `getSnapshot` still runs on every render.
+* @param getSnapshot - Reads the current value. Called on mount and again after
+*   every dispatch of `signal`.
+*/
+const useSignal = (signal, getSnapshot) => {
+	const subscribe = useCallback((onStoreChange) => {
+		if (!signal) return () => {};
+		signal.add(onStoreChange);
+		return () => {
+			signal.remove(onStoreChange);
+		};
+	}, [signal]);
+	return useSyncExternalStore(subscribe, getSnapshot);
+};
 
+//#endregion
 export { useSignal };
-//# sourceMappingURL=useSignal.js.map
+//# sourceMappingURL=useSignal.js.map

package/dist/esm/useSignal.js.map

@@ -1 +1 @@
-{"version":3,"file":"useSignal.js","sources":["../../../src/useSignal.ts"],"sourcesContent":[null],"names":[],"mappings":";;AAGA;;;;;;;;;;;;;;;;;;;;;;;;;AAyBG;AACG,SAAU,SAAS,CAA4B,MAAuC,EAAE,WAAoB,EAAA;AAChH,IAAA,MAAM,SAAS,GAAG,WAAW,CAC3B,CAAC,aAAyB,KAAkB;QAC1C,IAAI,CAAC,MAAM,EAAE;;;AAGX,YAAA,OAAO,MAAK,EAAE,CAAC;QACjB;AAEA,QAAA,MAAM,CAAC,GAAG,CAAC,aAAa,CAAC;AAEzB,QAAA,OAAO,MAAK;AACV,YAAA,MAAM,CAAC,MAAM,CAAC,aAAa,CAAC;AAC9B,QAAA,CAAC;AACH,IAAA,CAAC,EACD,CAAC,MAAM,CAAC,CACT;AAED,IAAA,OAAO,oBAAoB,CAAC,SAAS,EAAE,WAAW,CAAC;AACrD;;;;"}
+{"version":3,"file":"useSignal.js","names":[],"sources":["../../src/useSignal.ts"],"sourcesContent":["import type { Signal } from '@codexo/exojs';\nimport { useCallback, useSyncExternalStore } from 'react';\n\n/**\n * Subscribes to an ExoJS {@link Signal} and returns the latest value computed by\n * `getSnapshot`, re-rendering the component every time the signal dispatches.\n * Built on `useSyncExternalStore`, so reads stay tear-free under concurrent\n * rendering.\n *\n * The signal itself is only used to know *when* to re-read - `getSnapshot` is\n * responsible for producing the actual value (usually a getter on the engine\n * object the signal lives on).\n *\n * @example\n * ```tsx\n * function FrameCounter() {\n *   const app = useExoApp();\n *   // Re-renders on every `onFrame` dispatch (i.e. every engine frame).\n *   const frameCount = useSignal(app.onFrame, () => app.frameCount);\n *   return <span>Frame: {frameCount}</span>;\n * }\n * ```\n *\n * @param signal - The signal to subscribe to. `null`/`undefined` is accepted\n *   (e.g. before an `Application` exists) - the hook simply does not subscribe\n *   to anything and `getSnapshot` still runs on every render.\n * @param getSnapshot - Reads the current value. Called on mount and again after\n *   every dispatch of `signal`.\n */\nexport const useSignal = <Args extends unknown[], T>(signal: Signal<Args> | null | undefined, getSnapshot: () => T): T => {\n  const subscribe = useCallback(\n    (onStoreChange: () => void): (() => void) => {\n      if (!signal) {\n        // No signal to subscribe to (e.g. before an Application exists) - nothing to unsubscribe either.\n        return () => {\n          // Nothing was subscribed, so there is nothing to unsubscribe.\n        };\n      }\n\n      signal.add(onStoreChange);\n\n      return () => {\n        signal.remove(onStoreChange);\n      };\n    },\n    [signal],\n  );\n\n  return useSyncExternalStore(subscribe, getSnapshot);\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAa,aAAwC,QAAyC,gBAA4B;CACxH,MAAM,YAAY,aACf,kBAA4C;EAC3C,IAAI,CAAC,QAEH,aAAa,CAEb;EAGF,OAAO,IAAI,aAAa;EAExB,aAAa;GACX,OAAO,OAAO,aAAa;EAC7B;CACF,GACA,CAAC,MAAM,CACT;CAEA,OAAO,qBAAqB,WAAW,WAAW;AACpD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codexo/exojs-react",
-  "version": "0.15.2",
+  "version": "0.16.0",
   "description": "React integration for ExoJS.",
   "repository": {
     "type": "git",
@@ -26,7 +26,7 @@
     "LICENSE"
   ],
   "peerDependencies": {
-    "@codexo/exojs": "0.15.x",
+    "@codexo/exojs": "0.16.x",
     "react": ">=18.0.0",
     "react-dom": ">=18.0.0"
   },
@@ -36,18 +36,22 @@
     }
   },
   "devDependencies": {
-    "@types/react": "^18.0.0",
-    "@codexo/exojs-config": "0.0.0",
-    "@codexo/exojs": "0.15.2"
+    "@testing-library/dom": "^10.4.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/react": "^19.2.17",
+    "eslint": "~10.9.1",
+    "eslint-config-prettier": "^10.1.8",
+    "@codexo/exojs": "0.16.0",
+    "@codexo/exojs-config": "0.0.0"
   },
   "license": "MIT",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "tsx ../../node_modules/rollup/dist/bin/rollup -c --environment EXOJS_ENV:production",
-    "build:dev": "tsx ../../node_modules/rollup/dist/bin/rollup -c --environment EXOJS_ENV:development",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint \"src/**/*.{ts,tsx}\""
+    "build": "tsx ../../scripts/build-extension.ts",
+    "build:dev": "tsx ../../scripts/build-extension.ts --dev",
+    "typecheck": "tsc --noEmit && tsc --noEmit -p tsconfig.test.json && tsc --noEmit -p tsconfig.examples.json",
+    "lint": "eslint --max-warnings=0 ."
   }
 }

package/dist/esm/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}