pixi-solid 0.0.12 → 0.0.14

package/dist/index.js

@@ -1,35 +1,35 @@
-import { PixiApplication as r, usePixiApp as t } from "./pixi-application.js";
-import { PixiCanvas as o } from "./pixi-canvas.js";
-import { AnimatedSprite as x, BitmapText as a, Container as s, Graphics as m, HTMLText as S, MeshPlane as P, MeshRope as T, MeshSimple as c, NineSliceSprite as f, ParticleContainer as E, PerspectiveMesh as M, RenderContainer as l, RenderLayer as A, Sprite as N, Text as _, TilingSprite as h } from "./pixi-components.js";
-import { PIXI_EVENT_NAMES as R, PIXI_SOLID_EVENT_HANDLER_NAMES as u } from "./pixi-events.js";
-import { PixiStage as L } from "./pixi-stage.js";
-import { useResize as g } from "./use-resize.js";
-import { useTick as v, useTicker as D } from "./use-ticker.js";
+import { PixiApplication, TickerProvider, usePixiApp, useTick, useTicker } from "./pixi-application.js";
+import { PixiCanvas } from "./pixi-canvas.js";
+import { AnimatedSprite, BitmapText, Container, Graphics, HTMLText, MeshPlane, MeshRope, MeshSimple, NineSliceSprite, ParticleContainer, PerspectiveMesh, RenderContainer, RenderLayer, Sprite, Text, TilingSprite } from "./pixi-components.js";
+import { PIXI_EVENT_NAMES, PIXI_SOLID_EVENT_HANDLER_NAMES } from "./pixi-events.js";
+import { PixiStage } from "./pixi-stage.js";
+import { useResize } from "./use-resize.js";
 export {
-  x as AnimatedSprite,
-  a as BitmapText,
-  s as Container,
-  m as Graphics,
-  S as HTMLText,
-  P as MeshPlane,
-  T as MeshRope,
-  c as MeshSimple,
-  f as NineSliceSprite,
-  R as PIXI_EVENT_NAMES,
-  u as PIXI_SOLID_EVENT_HANDLER_NAMES,
-  E as ParticleContainer,
-  M as PerspectiveMesh,
-  r as PixiApplication,
-  o as PixiCanvas,
-  L as PixiStage,
-  l as RenderContainer,
-  A as RenderLayer,
-  N as Sprite,
-  _ as Text,
-  h as TilingSprite,
-  t as usePixiApp,
-  g as useResize,
-  v as useTick,
-  D as useTicker
+  AnimatedSprite,
+  BitmapText,
+  Container,
+  Graphics,
+  HTMLText,
+  MeshPlane,
+  MeshRope,
+  MeshSimple,
+  NineSliceSprite,
+  PIXI_EVENT_NAMES,
+  PIXI_SOLID_EVENT_HANDLER_NAMES,
+  ParticleContainer,
+  PerspectiveMesh,
+  PixiApplication,
+  PixiCanvas,
+  PixiStage,
+  RenderContainer,
+  RenderLayer,
+  Sprite,
+  Text,
+  TickerProvider,
+  TilingSprite,
+  usePixiApp,
+  useResize,
+  useTick,
+  useTicker
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/dist/pixi-application.js

@@ -1,44 +1,95 @@
-import { createComponent as i } from "solid-js/web";
-import { Application as c } from "pixi.js";
-import { createContext as a, useContext as s, splitProps as p, createResource as u, createEffect as l, onCleanup as d, Show as f } from "solid-js";
-const n = a(), w = () => {
-  const t = s(n);
-  if (!t)
+import { createComponent } from "solid-js/web";
+import { Application } from "pixi.js";
+import { createContext, useContext, splitProps, createResource, createEffect, onCleanup, Show } from "solid-js";
+const PixiAppContext = createContext();
+const TickerContext = createContext();
+const usePixiApp = () => {
+  const app = useContext(PixiAppContext);
+  if (!app) {
     throw new Error("usePixiApp must be used within a PixiApplication");
-  return t;
-}, A = (t) => {
-  const [h, o] = p(t, ["ref", "children"]), [r] = u(async () => {
-    const e = new c();
-    return await e.init({
-      autoDensity: !0,
+  }
+  return app;
+};
+const PixiApplication = (props) => {
+  const [_solidProps, initialisationProps] = splitProps(props, ["ref", "children"]);
+  const [appResource] = createResource(async () => {
+    const app = new Application();
+    await app.init({
+      autoDensity: true,
       resolution: Math.min(window.devicePixelRatio, 2),
-      sharedTicker: !0,
-      ...o
-    }), e;
+      sharedTicker: true,
+      ...initialisationProps
+    });
+    return app;
   });
-  return l(() => {
-    const e = r();
-    e && (t.ref && t.ref(e), e.ticker.autoStart = !1, e.ticker.start(), d(() => {
-      e.destroy(!0, {
-        children: !0
+  createEffect(() => {
+    const app = appResource();
+    if (app) {
+      if (props.ref) {
+        props.ref(app);
+      }
+      app.ticker.autoStart = false;
+      app.ticker.start();
+      onCleanup(() => {
+        app.destroy(true, {
+          children: true
+        });
       });
-    }));
-  }), i(f, {
+    }
+  });
+  return createComponent(Show, {
     get when() {
-      return r();
+      return appResource();
     },
-    children: (e) => i(n.Provider, {
+    children: (app) => createComponent(PixiAppContext.Provider, {
       get value() {
-        return e();
+        return app();
       },
       get children() {
-        return t.children;
+        return createComponent(TickerContext.Provider, {
+          get value() {
+            return app().ticker;
+          },
+          get children() {
+            return props.children;
+          }
+        });
       }
     })
   });
 };
+const TickerProvider = (props) => {
+  return createComponent(TickerContext.Provider, {
+    get value() {
+      return props.ticker;
+    },
+    get children() {
+      return props.children;
+    }
+  });
+};
+const useTicker = () => {
+  const ticker = useContext(TickerContext);
+  if (!ticker) {
+    throw new Error("useTicker must be used within a PixiApplication or a TickerProvider");
+  }
+  return ticker;
+};
+const useTick = (tickerCallback) => {
+  const ticker = useContext(TickerContext);
+  if (!ticker) {
+    throw new Error("useTick must be used within a PixiApplication or a TickerProvider");
+  }
+  ticker.add(tickerCallback);
+  onCleanup(() => {
+    ticker.remove(tickerCallback);
+  });
+};
 export {
-  A as PixiApplication,
-  w as usePixiApp
+  PixiApplication,
+  TickerProvider,
+  usePixiApp,
+  useTick,
+  useTicker
 };
 //# sourceMappingURL=pixi-application.js.map

package/dist/pixi-application.js.map

@@ -1 +1 @@
-{"version":3,"file":"pixi-application.js","sources":["../src/pixi-application.tsx"],"sourcesContent":["import type { ApplicationOptions } from \"pixi.js\";\nimport { Application } from \"pixi.js\";\nimport type { JSX, Ref } from \"solid-js\";\nimport { createContext, createEffect, createResource, onCleanup, Show, splitProps, useContext } from \"solid-js\";\n\nconst PixiAppContext = createContext<Application>();\n\n/**\n * A custom SolidJS hook to access the root PIXI.Application instance.\n * This hook must be called from a component that is a descendant of `PixiApplication`.\n *\n * @returns The PIXI.Application instance provided by the `PixiApplication` component.\n * @throws Will throw an error if used outside of a `PixiApplication` context provider.\n */\nexport const usePixiApp = () => {\n  const app = useContext(PixiAppContext);\n  if (!app) {\n    throw new Error(\"usePixiApp must be used within a PixiApplication\");\n  }\n  return app;\n};\n\n/**\n * Props for the `PixiApplication` component. It extends the PIXI.ApplicationOptions\n * to allow passing configuration directly to the Pixi.js Application constructor,\n * but omits properties that are handled by the component itself.\n */\nexport type PixiApplicationProps = Partial<Omit<ApplicationOptions, \"children\" | \"resizeTo\">> & {\n  ref?: Ref<Application>;\n  children?: JSX.Element;\n};\n\n/**\n * A SolidJS component that creates and manages a PIXI.Application instance.\n * It provides the application instance through context to be used by child components\n * and custom hooks like `usePixiApp`, `useTick`, and `useTicker`.\n *\n * This component should only be used once in your application.\n *\n * @param props The properties to configure the Pixi.js Application.\n *\n */\nexport const PixiApplication = (props: PixiApplicationProps) => {\n  const [_solidProps, initialisationProps] = splitProps(props, [\"ref\", \"children\"]);\n\n  // TODO: Split props into initialisation props and runtime props\n\n  const [appResource] = createResource(async () => {\n    const app = new Application();\n    await app.init({\n      autoDensity: true,\n      resolution: Math.min(window.devicePixelRatio, 2),\n      sharedTicker: true,\n      ...initialisationProps,\n    });\n\n    return app;\n  });\n\n  createEffect(() => {\n    const app = appResource();\n    if (app) {\n      if (props.ref) {\n        // Solid converts the ref prop to a callback function\n        (props.ref as unknown as (arg: any) => void)(app);\n      }\n\n      // TODO: Go through the other props that can be set at runtime and apply them here\n      // e.g. backgroundColor => app.renderer.backgroundColor, etc.\n\n      app.ticker.autoStart = false;\n      app.ticker.start();\n\n      onCleanup(() => {\n        app.destroy(true, { children: true });\n      });\n    }\n  });\n\n  return (\n    <Show when={appResource()}>\n      {(app) => <PixiAppContext.Provider value={app()}>{props.children}</PixiAppContext.Provider>}\n    </Show>\n  );\n};\n"],"names":["PixiAppContext","createContext","usePixiApp","app","useContext","Error","PixiApplication","props","_solidProps","initialisationProps","splitProps","appResource","createResource","Application","init","autoDensity","resolution","Math","min","window","devicePixelRatio","sharedTicker","createEffect","ref","ticker","autoStart","start","onCleanup","destroy","children","_$createComponent","Show","when","Provider","value"],"mappings":";;;AAKA,MAAMA,IAAiBC,EAAAA,GASVC,IAAaA,MAAM;AAC9B,QAAMC,IAAMC,EAAWJ,CAAc;AACrC,MAAI,CAACG;AACH,UAAM,IAAIE,MAAM,kDAAkD;AAEpE,SAAOF;AACT,GAsBaG,IAAkBA,CAACC,MAAgC;AAC9D,QAAM,CAACC,GAAaC,CAAmB,IAAIC,EAAWH,GAAO,CAAC,OAAO,UAAU,CAAC,GAI1E,CAACI,CAAW,IAAIC,EAAe,YAAY;AAC/C,UAAMT,IAAM,IAAIU,EAAAA;AAChB,iBAAMV,EAAIW,KAAK;AAAA,MACbC,aAAa;AAAA,MACbC,YAAYC,KAAKC,IAAIC,OAAOC,kBAAkB,CAAC;AAAA,MAC/CC,cAAc;AAAA,MACd,GAAGZ;AAAAA,IAAAA,CACJ,GAEMN;AAAAA,EACT,CAAC;AAEDmB,SAAAA,EAAa,MAAM;AACjB,UAAMnB,IAAMQ,EAAAA;AACZ,IAAIR,MACEI,EAAMgB,OAEPhB,EAAMgB,IAAsCpB,CAAG,GAMlDA,EAAIqB,OAAOC,YAAY,IACvBtB,EAAIqB,OAAOE,MAAAA,GAEXC,EAAU,MAAM;AACdxB,MAAAA,EAAIyB,QAAQ,IAAM;AAAA,QAAEC,UAAU;AAAA,MAAA,CAAM;AAAA,IACtC,CAAC;AAAA,EAEL,CAAC,GAEDC,EACGC,GAAI;AAAA,IAAA,IAACC,OAAI;AAAA,aAAErB,EAAAA;AAAAA,IAAa;AAAA,IAAAkB,UACrB1B,CAAAA,MAAG2B,EAAM9B,EAAeiC,UAAQ;AAAA,MAAA,IAACC,QAAK;AAAA,eAAE/B,EAAAA;AAAAA,MAAK;AAAA,MAAA,IAAA0B,WAAA;AAAA,eAAGtB,EAAMsB;AAAAA,MAAQ;AAAA,IAAA,CAAA;AAAA,EAAA,CAA2B;AAGjG;"}
+{"version":3,"file":"pixi-application.js","sources":["../src/pixi-application.tsx"],"sourcesContent":["import type { ApplicationOptions, Ticker, TickerCallback } from \"pixi.js\";\nimport { Application } from \"pixi.js\";\nimport type { JSX, ParentProps, Ref } from \"solid-js\";\nimport { createContext, createEffect, createResource, onCleanup, Show, splitProps, useContext } from \"solid-js\";\n\nconst PixiAppContext = createContext<Application>();\nconst TickerContext = createContext<Ticker>();\n\n/**\n * A custom SolidJS hook to access the root PIXI.Application instance.\n * This hook must be called from a component that is a descendant of `PixiApplication`.\n *\n * @returns The PIXI.Application instance provided by the `PixiApplication` component.\n * @throws Will throw an error if used outside of a `PixiApplication` context provider.\n */\nexport const usePixiApp = () => {\n  const app = useContext(PixiAppContext);\n  if (!app) {\n    throw new Error(\"usePixiApp must be used within a PixiApplication\");\n  }\n  return app;\n};\n\n/**\n * Props for the `PixiApplication` component. It extends the PIXI.ApplicationOptions\n * to allow passing configuration directly to the Pixi.js Application constructor,\n * but omits properties that are handled by the component itself.\n */\nexport type PixiApplicationProps = Partial<Omit<ApplicationOptions, \"children\" | \"resizeTo\">> & {\n  ref?: Ref<Application>;\n  children?: JSX.Element;\n};\n\n/**\n * A SolidJS component that creates and manages a PIXI.Application instance.\n * It provides the application instance through context to be used by child components\n * and custom hooks like `usePixiApp`, `useTick`, and `useTicker`.\n *\n * This component should only be used once in your application.\n *\n * @param props The properties to configure the Pixi.js Application.\n *\n */\nexport const PixiApplication = (props: PixiApplicationProps) => {\n  const [_solidProps, initialisationProps] = splitProps(props, [\"ref\", \"children\"]);\n\n  // TODO: Split props into initialisation props and runtime props\n\n  const [appResource] = createResource(async () => {\n    const app = new Application();\n    await app.init({\n      autoDensity: true,\n      resolution: Math.min(window.devicePixelRatio, 2),\n      sharedTicker: true,\n      ...initialisationProps,\n    });\n\n    return app;\n  });\n\n  createEffect(() => {\n    const app = appResource();\n    if (app) {\n      if (props.ref) {\n        // Solid converts the ref prop to a callback function\n        (props.ref as unknown as (arg: any) => void)(app);\n      }\n\n      // TODO: Go through the other props that can be set at runtime and apply them here\n      // e.g. backgroundColor => app.renderer.backgroundColor, etc.\n\n      app.ticker.autoStart = false;\n      app.ticker.start();\n\n      onCleanup(() => {\n        app.destroy(true, { children: true });\n      });\n    }\n  });\n\n  return (\n    <Show when={appResource()}>\n      {(app) => (\n        <PixiAppContext.Provider value={app()}>\n          <TickerContext.Provider value={app().ticker}>{props.children}</TickerContext.Provider>\n        </PixiAppContext.Provider>\n      )}\n    </Show>\n  );\n};\n\nexport type TickerProviderProps = ParentProps<{ ticker: Ticker }>;\n\n/**\n * This is only required if you want a ticker without the Application.\n * It provides context for the `useTick` and `useTicker` hooks so we can run tests that use them without having to instantate a Pixi Application.\n *\n * You need to pass in the ticker instance you want to use so it can be manually controled form the outside for testing.\n */\nexport const TickerProvider = (props: TickerProviderProps) => {\n  return <TickerContext.Provider value={props.ticker}>{props.children}</TickerContext.Provider>;\n};\n\n/**\n * useTicker\n *\n * A custom SolidJS hook that provides access to the PIXI.Application's shared Ticker instance.\n * This hook must be called from a component that is a descendant of `PixiApplication`.\n * Or a descendant of `TickerProvider` if being used for testing without an application.\n *\n * @returns The PIXI.Ticker instance from the application context.\n * @throws Will throw an error if used outside of a `PixiApplication` or `TickerProvider` context.\n */\nexport const useTicker = (): Ticker => {\n  const ticker = useContext(TickerContext);\n  if (!ticker) {\n    throw new Error(\"useTicker must be used within a PixiApplication or a TickerProvider\");\n  }\n  return ticker;\n};\n\n/**\n * useTick\n *\n * A custom SolidJS hook that registers a callback function to be executed on every frame\n * of the PIXI.Application's ticker. The callback is automatically removed when the\n * component or hook's owning computation is cleaned up.\n *\n * This hook must be called from a component that is a descendant of `PixiApplication`.\n * Or a descendant of `TickerProvider` if being used for testing without an application.\n *\n * @param tickerCallback - The function to call on each ticker update. It receives\n * the `PIXI.Ticker` instance as its argument.\n *\n */\nexport const useTick = (tickerCallback: TickerCallback<Ticker>): void => {\n  const ticker = useContext(TickerContext);\n\n  if (!ticker) {\n    throw new Error(\"useTick must be used within a PixiApplication or a TickerProvider\");\n  }\n\n  ticker.add(tickerCallback);\n  onCleanup(() => {\n    ticker.remove(tickerCallback);\n  });\n};\n"],"names":["PixiAppContext","createContext","TickerContext","usePixiApp","app","useContext","Error","PixiApplication","props","_solidProps","initialisationProps","splitProps","appResource","createResource","Application","init","autoDensity","resolution","Math","min","window","devicePixelRatio","sharedTicker","createEffect","ref","ticker","autoStart","start","onCleanup","destroy","children","_$createComponent","Show","when","Provider","value","TickerProvider","useTicker","useTick","tickerCallback","add","remove"],"mappings":";;;AAKA,MAAMA,iBAAiBC,cAAAA;AACvB,MAAMC,gBAAgBD,cAAAA;AASf,MAAME,aAAaA,MAAM;AAC9B,QAAMC,MAAMC,WAAWL,cAAc;AACrC,MAAI,CAACI,KAAK;AACR,UAAM,IAAIE,MAAM,kDAAkD;AAAA,EACpE;AACA,SAAOF;AACT;AAsBO,MAAMG,kBAAkBA,CAACC,UAAgC;AAC9D,QAAM,CAACC,aAAaC,mBAAmB,IAAIC,WAAWH,OAAO,CAAC,OAAO,UAAU,CAAC;AAIhF,QAAM,CAACI,WAAW,IAAIC,eAAe,YAAY;AAC/C,UAAMT,MAAM,IAAIU,YAAAA;AAChB,UAAMV,IAAIW,KAAK;AAAA,MACbC,aAAa;AAAA,MACbC,YAAYC,KAAKC,IAAIC,OAAOC,kBAAkB,CAAC;AAAA,MAC/CC,cAAc;AAAA,MACd,GAAGZ;AAAAA,IAAAA,CACJ;AAED,WAAON;AAAAA,EACT,CAAC;AAEDmB,eAAa,MAAM;AACjB,UAAMnB,MAAMQ,YAAAA;AACZ,QAAIR,KAAK;AACP,UAAII,MAAMgB,KAAK;AAEZhB,cAAMgB,IAAsCpB,GAAG;AAAA,MAClD;AAKAA,UAAIqB,OAAOC,YAAY;AACvBtB,UAAIqB,OAAOE,MAAAA;AAEXC,gBAAU,MAAM;AACdxB,YAAIyB,QAAQ,MAAM;AAAA,UAAEC,UAAU;AAAA,QAAA,CAAM;AAAA,MACtC,CAAC;AAAA,IACH;AAAA,EACF,CAAC;AAED,SAAAC,gBACGC,MAAI;AAAA,IAAA,IAACC,OAAI;AAAA,aAAErB,YAAAA;AAAAA,IAAa;AAAA,IAAAkB,UACrB1B,CAAAA,QAAG2B,gBACF/B,eAAekC,UAAQ;AAAA,MAAA,IAACC,QAAK;AAAA,eAAE/B,IAAAA;AAAAA,MAAK;AAAA,MAAA,IAAA0B,WAAA;AAAA,eAAAC,gBAClC7B,cAAcgC,UAAQ;AAAA,UAAA,IAACC,QAAK;AAAA,mBAAE/B,MAAMqB;AAAAA,UAAM;AAAA,UAAA,IAAAK,WAAA;AAAA,mBAAGtB,MAAMsB;AAAAA,UAAQ;AAAA,QAAA,CAAA;AAAA,MAAA;AAAA,IAAA,CAAA;AAAA,EAAA,CAE/D;AAGP;AAUO,MAAMM,iBAAiBA,CAAC5B,UAA+B;AAC5D,SAAAuB,gBAAQ7B,cAAcgC,UAAQ;AAAA,IAAA,IAACC,QAAK;AAAA,aAAE3B,MAAMiB;AAAAA,IAAM;AAAA,IAAA,IAAAK,WAAA;AAAA,aAAGtB,MAAMsB;AAAAA,IAAQ;AAAA,EAAA,CAAA;AACrE;AAYO,MAAMO,YAAYA,MAAc;AACrC,QAAMZ,SAASpB,WAAWH,aAAa;AACvC,MAAI,CAACuB,QAAQ;AACX,UAAM,IAAInB,MAAM,qEAAqE;AAAA,EACvF;AACA,SAAOmB;AACT;AAgBO,MAAMa,UAAUA,CAACC,mBAAiD;AACvE,QAAMd,SAASpB,WAAWH,aAAa;AAEvC,MAAI,CAACuB,QAAQ;AACX,UAAM,IAAInB,MAAM,mEAAmE;AAAA,EACrF;AAEAmB,SAAOe,IAAID,cAAc;AACzBX,YAAU,MAAM;AACdH,WAAOgB,OAAOF,cAAc;AAAA,EAC9B,CAAC;AACH;"}

package/dist/pixi-canvas.js

@@ -1,35 +1,59 @@
-import { template as l, insert as u, effect as f, style as m, className as d, use as p } from "solid-js/web";
-import { createRenderEffect as z, onMount as y, onCleanup as x } from "solid-js";
-import { usePixiApp as b } from "./pixi-application.js";
-var R = /* @__PURE__ */ l("<div>");
-const q = (o) => {
-  let r;
-  const e = b();
-  e.canvas.style.display = "block", z(() => {
-    if (o.children === void 0)
+import { template, insert, effect, style, className, use } from "solid-js/web";
+import { createRenderEffect, onMount, onCleanup } from "solid-js";
+import { usePixiApp } from "./pixi-application.js";
+var _tmpl$ = /* @__PURE__ */ template(`<div style=position:relative>`);
+const PixiCanvas = (props) => {
+  let canvasWrapElement;
+  const pixiApp = usePixiApp();
+  pixiApp.canvas.style.display = "block";
+  pixiApp.canvas.style.position = "absolute";
+  pixiApp.canvas.style.top = "0";
+  pixiApp.canvas.style.left = "0";
+  pixiApp.canvas.style.width = "100%";
+  pixiApp.canvas.style.height = "100%";
+  createRenderEffect(() => {
+    if (props.children === void 0) {
       throw new Error("PixiCanvas requires the `PixiStage` component to render.");
+    }
   });
-  let n, s;
-  return y(() => {
-    r && (n = e.resizeTo, e.resizeTo = r, e.queueResize(), s = new ResizeObserver(() => {
-      e.queueResize();
-    }), s.observe(r));
-  }), x(() => {
-    r && (e.resizeTo = n, s?.disconnect(), s = void 0);
-  }), (() => {
-    var t = R(), a = r;
-    return typeof a == "function" ? p(a, t) : r = t, u(t, () => e.canvas), f((i) => {
-      var c = {
-        ...typeof o.style == "object" ? o.style : {}
-      }, v = o.className;
-      return i.e = m(t, c, i.e), v !== i.t && d(t, i.t = v), i;
+  let previousResizeTo;
+  let resizeObserver;
+  onMount(() => {
+    if (!canvasWrapElement) return;
+    previousResizeTo = pixiApp.resizeTo;
+    pixiApp.resizeTo = canvasWrapElement;
+    pixiApp.queueResize();
+    resizeObserver = new ResizeObserver(() => {
+      pixiApp.queueResize();
+    });
+    resizeObserver.observe(canvasWrapElement);
+  });
+  onCleanup(() => {
+    if (!canvasWrapElement) return;
+    pixiApp.resizeTo = previousResizeTo;
+    resizeObserver?.disconnect();
+    resizeObserver = void 0;
+  });
+  return (() => {
+    var _el$ = _tmpl$();
+    var _ref$ = canvasWrapElement;
+    typeof _ref$ === "function" ? use(_ref$, _el$) : canvasWrapElement = _el$;
+    insert(_el$, () => pixiApp.canvas);
+    effect((_p$) => {
+      var _v$ = {
+        ...typeof props.style === "object" ? props.style : {}
+      }, _v$2 = props.className;
+      _p$.e = style(_el$, _v$, _p$.e);
+      _v$2 !== _p$.t && className(_el$, _p$.t = _v$2);
+      return _p$;
     }, {
       e: void 0,
       t: void 0
-    }), t;
+    });
+    return _el$;
   })();
 };
 export {
-  q as PixiCanvas
+  PixiCanvas
 };
 //# sourceMappingURL=pixi-canvas.js.map

package/dist/pixi-canvas.js.map

@@ -1 +1 @@
-{"version":3,"file":"pixi-canvas.js","sources":["../src/pixi-canvas.tsx"],"sourcesContent":["import type { JSX } from \"solid-js\";\nimport { createRenderEffect, onCleanup, onMount } from \"solid-js\";\nimport { usePixiApp } from \"./pixi-application\";\n\n/**\n * PixiCanvas\n *\n * A small wrapper that mounts the PIXI application's canvas element into the DOM\n * and automatically resizes it.\n *\n * - Requires a surrounding `PixiApplication` component.\n * - Requires a `PixiStage` component as a child.\n *\n * Props:\n * @param props.children - JSX content to render inside the canvas wrapper. Use `PixiStage` as the only child.\n */\n\nexport const PixiCanvas = (props: {\n  children: JSX.Element;\n  style?: JSX.CSSProperties | undefined;\n  className?: string;\n}): JSX.Element => {\n  let canvasWrapElement: HTMLDivElement | undefined;\n\n  const pixiApp = usePixiApp();\n  pixiApp.canvas.style.display = \"block\";\n\n  createRenderEffect(() => {\n    if (props.children === undefined) {\n      throw new Error(\"PixiCanvas requires the `PixiStage` component to render.\");\n    }\n  });\n\n  let previousResizeTo: typeof pixiApp.resizeTo;\n  let resizeObserver: ResizeObserver | undefined;\n\n  onMount(() => {\n    if (!canvasWrapElement) return;\n    previousResizeTo = pixiApp.resizeTo;\n    pixiApp.resizeTo = canvasWrapElement;\n    pixiApp.queueResize();\n    resizeObserver = new ResizeObserver(() => {\n      pixiApp.queueResize();\n    });\n    resizeObserver.observe(canvasWrapElement);\n  });\n\n  onCleanup(() => {\n    if (!canvasWrapElement) return;\n    pixiApp.resizeTo = previousResizeTo;\n    resizeObserver?.disconnect();\n    resizeObserver = undefined;\n  });\n\n  return (\n    <div\n      ref={canvasWrapElement}\n      style={{\n        ...(typeof props.style === \"object\" ? props.style : {}),\n      }}\n      class={props.className}\n    >\n      {pixiApp.canvas}\n    </div>\n  );\n};\n"],"names":["PixiCanvas","props","canvasWrapElement","pixiApp","usePixiApp","canvas","style","display","createRenderEffect","children","undefined","Error","previousResizeTo","resizeObserver","onMount","resizeTo","queueResize","ResizeObserver","observe","onCleanup","disconnect","_el$","_tmpl$","_ref$","_$use","_$insert","_$effect","_p$","_v$","_v$2","className","e","_$style","t","_$className"],"mappings":";;;;AAiBO,MAAMA,IAAaA,CAACC,MAIR;AACjB,MAAIC;AAEJ,QAAMC,IAAUC,EAAAA;AAChBD,EAAAA,EAAQE,OAAOC,MAAMC,UAAU,SAE/BC,EAAmB,MAAM;AACvB,QAAIP,EAAMQ,aAAaC;AACrB,YAAM,IAAIC,MAAM,0DAA0D;AAAA,EAE9E,CAAC;AAED,MAAIC,GACAC;AAEJC,SAAAA,EAAQ,MAAM;AACZ,IAAKZ,MACLU,IAAmBT,EAAQY,UAC3BZ,EAAQY,WAAWb,GACnBC,EAAQa,YAAAA,GACRH,IAAiB,IAAII,eAAe,MAAM;AACxCd,MAAAA,EAAQa,YAAAA;AAAAA,IACV,CAAC,GACDH,EAAeK,QAAQhB,CAAiB;AAAA,EAC1C,CAAC,GAEDiB,EAAU,MAAM;AACd,IAAKjB,MACLC,EAAQY,WAAWH,GACnBC,GAAgBO,WAAAA,GAChBP,IAAiBH;AAAAA,EACnB,CAAC,IAED,MAAA;AAAA,QAAAW,IAAAC,EAAAA,GAAAC,IAESrB;AAAiB,kBAAAqB,KAAA,aAAAC,EAAAD,GAAAF,CAAA,IAAjBnB,IAAiBmB,GAAAI,EAAAJ,GAAA,MAMrBlB,EAAQE,MAAM,GAAAqB,EAAAC,CAAAA,MAAA;AAAA,UAAAC,IALR;AAAA,QACL,GAAI,OAAO3B,EAAMK,SAAU,WAAWL,EAAMK,QAAQ,CAAA;AAAA,MAAC,GACtDuB,IACM5B,EAAM6B;AAASH,aAAAA,EAAAI,IAAAC,EAAAX,GAAAO,GAAAD,EAAAI,CAAA,GAAAF,MAAAF,EAAAM,KAAAC,EAAAb,GAAAM,EAAAM,IAAAJ,CAAA,GAAAF;AAAAA,IAAA,GAAA;AAAA,MAAAI,GAAArB;AAAAA,MAAAuB,GAAAvB;AAAAA,IAAAA,CAAA,GAAAW;AAAAA,EAAA,GAAA;AAK5B;"}
+{"version":3,"file":"pixi-canvas.js","sources":["../src/pixi-canvas.tsx"],"sourcesContent":["import type { JSX } from \"solid-js\";\nimport { createRenderEffect, onCleanup, onMount } from \"solid-js\";\nimport { usePixiApp } from \"./pixi-application\";\n\n/**\n * PixiCanvas\n *\n * A small wrapper that mounts the PIXI application's canvas element into the DOM\n * and automatically resizes it.\n *\n * - Requires a surrounding `PixiApplication` component.\n * - Requires a `PixiStage` component as a child.\n *\n * Props:\n * @param props.children - JSX content to render inside the canvas wrapper. Use `PixiStage` as the only child.\n */\n\nexport const PixiCanvas = (props: {\n  children: JSX.Element;\n  style?: JSX.CSSProperties | undefined;\n  className?: string;\n}): JSX.Element => {\n  let canvasWrapElement: HTMLDivElement | undefined;\n\n  const pixiApp = usePixiApp();\n  pixiApp.canvas.style.display = \"block\";\n  pixiApp.canvas.style.position = \"absolute\";\n  pixiApp.canvas.style.top = \"0\";\n  pixiApp.canvas.style.left = \"0\";\n  pixiApp.canvas.style.width = \"100%\";\n  pixiApp.canvas.style.height = \"100%\";\n\n  createRenderEffect(() => {\n    if (props.children === undefined) {\n      throw new Error(\"PixiCanvas requires the `PixiStage` component to render.\");\n    }\n  });\n\n  let previousResizeTo: typeof pixiApp.resizeTo;\n  let resizeObserver: ResizeObserver | undefined;\n\n  onMount(() => {\n    if (!canvasWrapElement) return;\n    previousResizeTo = pixiApp.resizeTo;\n    pixiApp.resizeTo = canvasWrapElement;\n    pixiApp.queueResize();\n    resizeObserver = new ResizeObserver(() => {\n      pixiApp.queueResize();\n    });\n    resizeObserver.observe(canvasWrapElement);\n  });\n\n  onCleanup(() => {\n    if (!canvasWrapElement) return;\n    pixiApp.resizeTo = previousResizeTo;\n    resizeObserver?.disconnect();\n    resizeObserver = undefined;\n  });\n\n  return (\n    <div\n      ref={canvasWrapElement}\n      style={{\n        position: \"relative\",\n        ...(typeof props.style === \"object\" ? props.style : {}),\n      }}\n      class={props.className}\n    >\n      {pixiApp.canvas}\n    </div>\n  );\n};\n"],"names":["PixiCanvas","props","canvasWrapElement","pixiApp","usePixiApp","canvas","style","display","position","top","left","width","height","createRenderEffect","children","undefined","Error","previousResizeTo","resizeObserver","onMount","resizeTo","queueResize","ResizeObserver","observe","onCleanup","disconnect","_el$","_tmpl$","_ref$","_$use","_$insert","_$effect","_p$","_v$","_v$2","className","e","_$style","t","_$className"],"mappings":";;;;AAiBO,MAAMA,aAAaA,CAACC,UAIR;AACjB,MAAIC;AAEJ,QAAMC,UAAUC,WAAAA;AAChBD,UAAQE,OAAOC,MAAMC,UAAU;AAC/BJ,UAAQE,OAAOC,MAAME,WAAW;AAChCL,UAAQE,OAAOC,MAAMG,MAAM;AAC3BN,UAAQE,OAAOC,MAAMI,OAAO;AAC5BP,UAAQE,OAAOC,MAAMK,QAAQ;AAC7BR,UAAQE,OAAOC,MAAMM,SAAS;AAE9BC,qBAAmB,MAAM;AACvB,QAAIZ,MAAMa,aAAaC,QAAW;AAChC,YAAM,IAAIC,MAAM,0DAA0D;AAAA,IAC5E;AAAA,EACF,CAAC;AAED,MAAIC;AACJ,MAAIC;AAEJC,UAAQ,MAAM;AACZ,QAAI,CAACjB,kBAAmB;AACxBe,uBAAmBd,QAAQiB;AAC3BjB,YAAQiB,WAAWlB;AACnBC,YAAQkB,YAAAA;AACRH,qBAAiB,IAAII,eAAe,MAAM;AACxCnB,cAAQkB,YAAAA;AAAAA,IACV,CAAC;AACDH,mBAAeK,QAAQrB,iBAAiB;AAAA,EAC1C,CAAC;AAEDsB,YAAU,MAAM;AACd,QAAI,CAACtB,kBAAmB;AACxBC,YAAQiB,WAAWH;AACnBC,oBAAgBO,WAAAA;AAChBP,qBAAiBH;AAAAA,EACnB,CAAC;AAED,UAAA,MAAA;AAAA,QAAAW,OAAAC,OAAAA;AAAA,QAAAC,QAES1B;AAAiB,WAAA0B,UAAA,aAAAC,IAAAD,OAAAF,IAAA,IAAjBxB,oBAAiBwB;AAAAI,WAAAJ,MAAA,MAOrBvB,QAAQE,MAAM;AAAA0B,WAAAC,CAAAA,QAAA;AAAA,UAAAC,MANR;AAAA,QAEL,GAAI,OAAOhC,MAAMK,UAAU,WAAWL,MAAMK,QAAQ,CAAA;AAAA,MAAC,GACtD4B,OACMjC,MAAMkC;AAASH,UAAAI,IAAAC,MAAAX,MAAAO,KAAAD,IAAAI,CAAA;AAAAF,eAAAF,IAAAM,KAAAC,UAAAb,MAAAM,IAAAM,IAAAJ,IAAA;AAAA,aAAAF;AAAAA,IAAA,GAAA;AAAA,MAAAI,GAAArB;AAAAA,MAAAuB,GAAAvB;AAAAA,IAAAA,CAAA;AAAA,WAAAW;AAAAA,EAAA,GAAA;AAK5B;"}

package/dist/pixi-components.js

@@ -1,49 +1,83 @@
-import { RenderContainer as l, RenderLayer as S, AnimatedSprite as h, BitmapText as m, Container as P, Graphics as d, HTMLText as M, MeshPlane as T, MeshRope as $, MeshSimple as f, NineSliceSprite as C, ParticleContainer as R, PerspectiveMesh as x, Sprite as L, Text as u, TilingSprite as E } from "pixi.js";
-import { splitProps as N, createRenderEffect as s, on as _ } from "solid-js";
-import { PIXI_SOLID_EVENT_HANDLER_NAMES as y } from "./pixi-events.js";
-import { insert as A, setProp as c } from "./renderer.js";
-const H = ["ref", "as", "children"], p = (i, n, r) => {
-  for (const t in n)
-    if (t !== "as")
-      if (t === "ref")
-        s(() => {
-          n[t](i);
-        });
-      else if (t === "children") {
-        if (!("addChild" in i))
-          throw new Error("Cannot set children on non-container instance.");
-        s(() => {
-          A(i, () => n.children);
-        });
-      } else r ? s(_(() => n[t], () => {
-        c(i, t, n[t]);
+import { RenderContainer as RenderContainer$1, RenderLayer as RenderLayer$1, AnimatedSprite as AnimatedSprite$1, BitmapText as BitmapText$1, Container as Container$1, Graphics as Graphics$1, HTMLText as HTMLText$1, MeshPlane as MeshPlane$1, MeshRope as MeshRope$1, MeshSimple as MeshSimple$1, NineSliceSprite as NineSliceSprite$1, ParticleContainer as ParticleContainer$1, PerspectiveMesh as PerspectiveMesh$1, Sprite as Sprite$1, Text as Text$1, TilingSprite as TilingSprite$1 } from "pixi.js";
+import { splitProps, createRenderEffect, on } from "solid-js";
+import { PIXI_SOLID_EVENT_HANDLER_NAMES } from "./pixi-events.js";
+import { insert, setProp } from "./renderer.js";
+const SOLID_PROP_KEYS = ["ref", "as", "children"];
+const applyProps = (instance, props, defer) => {
+  for (const key in props) {
+    if (key === "as") continue;
+    if (key === "ref") {
+      createRenderEffect(() => {
+        props[key](instance);
+      });
+    } else if (key === "children") {
+      if (!("addChild" in instance)) {
+        throw new Error(`Cannot set children on non-container instance.`);
+      }
+      createRenderEffect(() => {
+        insert(instance, () => props.children);
+      });
+    } else if (defer) {
+      createRenderEffect(on(() => props[key], () => {
+        setProp(instance, key, props[key]);
       }, {
-        defer: r
-      })) : s(() => {
-        c(i, t, n[t]);
+        defer
+      }));
+    } else {
+      createRenderEffect(() => {
+        setProp(instance, key, props[key]);
       });
-}, o = (i) => (n) => {
-  const [r, t] = N(n, [...H, ...y]), a = n.as || new i(t);
-  return p(a, t, !0), p(a, r), a;
-}, e = (i) => (n) => o(i)(n), B = e(h), D = e(m), G = o(P), O = e(d), k = e(M), K = e(T), V = e($), X = e(f), Y = e(C), b = e(R), j = e(x), q = o(l), z = o(S), F = e(L), J = e(u), Q = e(E);
+    }
+  }
+};
+const createContainerComponent = (PixiClass) => {
+  return (props) => {
+    const [runtimeProps, initialisationProps] = splitProps(props, [...SOLID_PROP_KEYS, ...PIXI_SOLID_EVENT_HANDLER_NAMES]);
+    const instance = props.as || new PixiClass(initialisationProps);
+    applyProps(instance, initialisationProps, true);
+    applyProps(instance, runtimeProps);
+    return instance;
+  };
+};
+const createLeafComponent = (PixiClass) => {
+  return (props) => {
+    return createContainerComponent(PixiClass)(props);
+  };
+};
+const AnimatedSprite = createLeafComponent(AnimatedSprite$1);
+const BitmapText = createLeafComponent(BitmapText$1);
+const Container = createContainerComponent(Container$1);
+const Graphics = createLeafComponent(Graphics$1);
+const HTMLText = createLeafComponent(HTMLText$1);
+const MeshPlane = createLeafComponent(MeshPlane$1);
+const MeshRope = createLeafComponent(MeshRope$1);
+const MeshSimple = createLeafComponent(MeshSimple$1);
+const NineSliceSprite = createLeafComponent(NineSliceSprite$1);
+const ParticleContainer = createLeafComponent(ParticleContainer$1);
+const PerspectiveMesh = createLeafComponent(PerspectiveMesh$1);
+const RenderContainer = createContainerComponent(RenderContainer$1);
+const RenderLayer = createContainerComponent(RenderLayer$1);
+const Sprite = createLeafComponent(Sprite$1);
+const Text = createLeafComponent(Text$1);
+const TilingSprite = createLeafComponent(TilingSprite$1);
 export {
-  B as AnimatedSprite,
-  D as BitmapText,
-  G as Container,
-  O as Graphics,
-  k as HTMLText,
-  K as MeshPlane,
-  V as MeshRope,
-  X as MeshSimple,
-  Y as NineSliceSprite,
-  b as ParticleContainer,
-  j as PerspectiveMesh,
-  q as RenderContainer,
-  z as RenderLayer,
-  H as SOLID_PROP_KEYS,
-  F as Sprite,
-  J as Text,
-  Q as TilingSprite,
-  p as applyProps
+  AnimatedSprite,
+  BitmapText,
+  Container,
+  Graphics,
+  HTMLText,
+  MeshPlane,
+  MeshRope,
+  MeshSimple,
+  NineSliceSprite,
+  ParticleContainer,
+  PerspectiveMesh,
+  RenderContainer,
+  RenderLayer,
+  SOLID_PROP_KEYS,
+  Sprite,
+  Text,
+  TilingSprite,
+  applyProps
 };
 //# sourceMappingURL=pixi-components.js.map

package/dist/pixi-components.js.map

@@ -1 +1 @@
-{"version":3,"file":"pixi-components.js","sources":["../src/pixi-components.tsx"],"sourcesContent":["import type * as Pixi from \"pixi.js\";\nimport {\n  AnimatedSprite as PixiAnimatedSprite,\n  BitmapText as PixiBitmapText,\n  Container as PixiContainer,\n  Graphics as PixiGraphics,\n  HTMLText as PixiHTMLText,\n  MeshPlane as PixiMeshPlane,\n  MeshRope as PixiMeshRope,\n  MeshSimple as PixiMeshSimple,\n  NineSliceSprite as PixiNineSliceSprite,\n  ParticleContainer as PixiParticleContainer,\n  PerspectiveMesh as PixiPerspectiveMesh,\n  RenderContainer as PixiRenderContainer,\n  RenderLayer as PixiRenderLayer,\n  Sprite as PixiSprite,\n  Text as PixiText,\n  TilingSprite as PixiTilingSprite,\n} from \"pixi.js\";\nimport type { JSX, Ref } from \"solid-js\";\nimport { createRenderEffect, on, splitProps } from \"solid-js\";\nimport type { PixiEventHandlerMap } from \"./pixi-events\";\n\nimport { PIXI_SOLID_EVENT_HANDLER_NAMES } from \"./pixi-events\";\nimport { insert, setProp } from \"./renderer\";\n\n/**\n * Prop definition for components that CAN have children\n */\nexport type ContainerProps<Component> = PixiEventHandlerMap & {\n  ref?: Ref<Component>;\n  as?: Component;\n  children?: JSX.Element;\n};\n\n/**\n * Prop definition for components that CANNOT have children\n */\nexport type LeafProps<Component> = Omit<ContainerProps<Component>, \"children\">;\n\n// Keys that are specific to Solid components and not Pixi props\nexport const SOLID_PROP_KEYS = [\"ref\", \"as\", \"children\"] as const;\n\n/**\n * Apply's the props to a Pixi instance with subsriptions to maintain reactivity.\n *\n * @param instance The Pixi instance we want to apply props to.\n * @param props The props object.\n * @param defer Defers the createRenderEffect so the props aren't set on the first run.\n * This is useful because setting initialisation props can have unintended side effects.\n * Notibly in AnimatedSprite, if we set the textures roperty after instantiation it will stop the instance from playing.\n */\nexport const applyProps = <InstanceType extends PixiContainer, OptionsType extends ContainerProps<InstanceType>>(\n  instance: InstanceType,\n  props: OptionsType,\n  defer?: boolean\n) => {\n  for (const key in props) {\n    if (key === \"as\") continue;\n\n    if (key === \"ref\") {\n      createRenderEffect(() => {\n        // Solid converts the ref prop to a callback function\n        (props[key] as unknown as (arg: any) => void)(instance);\n      });\n    } else if (key === \"children\") {\n      if (!(\"addChild\" in instance)) {\n        throw new Error(`Cannot set children on non-container instance.`);\n      }\n      createRenderEffect(() => {\n        insert(instance, () => props.children);\n      });\n    } else if (defer) {\n      createRenderEffect(\n        on(\n          () => props[key as keyof typeof props],\n          () => {\n            setProp(instance, key, props[key as keyof typeof props]);\n          },\n          { defer }\n        )\n      );\n    } else {\n      createRenderEffect(() => {\n        setProp(instance, key, props[key as keyof typeof props]);\n      });\n    }\n  }\n};\n\nconst createContainerComponent = <InstanceType extends PixiContainer, OptionsType extends object>(\n  PixiClass: new (props: OptionsType) => InstanceType\n) => {\n  return (props: Omit<OptionsType, \"children\"> & ContainerProps<InstanceType>): JSX.Element => {\n    const [runtimeProps, initialisationProps] = splitProps(props, [\n      ...SOLID_PROP_KEYS,\n      ...PIXI_SOLID_EVENT_HANDLER_NAMES,\n    ]);\n\n    const instance = props.as || new PixiClass(initialisationProps as any);\n\n    applyProps(instance, initialisationProps, true);\n    applyProps(instance, runtimeProps);\n\n    return instance as unknown as JSX.Element;\n  };\n};\n\nconst createLeafComponent = <InstanceType extends PixiContainer, OptionsType extends object>(\n  PixiClass: new (props: OptionsType) => InstanceType\n) => {\n  return (props: Omit<OptionsType, \"children\"> & LeafProps<InstanceType>): JSX.Element => {\n    return createContainerComponent<PixiContainer, OptionsType>(PixiClass)(props as any);\n  };\n};\n\n/**\n * A SolidJS component that renders a `PIXI.AnimatedSprite`.\n */\nexport const AnimatedSprite = createLeafComponent<PixiAnimatedSprite, Pixi.AnimatedSpriteOptions>(PixiAnimatedSprite);\n/**\n * A SolidJS component that renders a `PIXI.BitmapText`.\n */\nexport const BitmapText = createLeafComponent<PixiBitmapText, ConstructorParameters<typeof PixiBitmapText>>(\n  PixiBitmapText\n);\n/**\n * A SolidJS component that renders a `PIXI.Container`.\n */\nexport const Container = createContainerComponent<PixiContainer, Pixi.ContainerOptions>(PixiContainer);\n/**\n * A SolidJS component that renders a `PIXI.Graphics`.\n * Use a ref to access the underlying graphics instance and draw with it.\n */\nexport const Graphics = createLeafComponent<PixiGraphics, Pixi.GraphicsOptions>(PixiGraphics);\n/**\n * A SolidJS component that renders a `PIXI.HTMLText`.\n */\nexport const HTMLText = createLeafComponent<PixiHTMLText, Pixi.HTMLTextOptions>(PixiHTMLText);\n\n/**\n * A SolidJS component that renders a `PIXI.MeshPlane`.\n */\nexport const MeshPlane = createLeafComponent<PixiMeshPlane, Pixi.MeshPlaneOptions>(PixiMeshPlane);\n\n/**\n * A SolidJS component that renders a `PIXI.MeshRope`.\n */\nexport const MeshRope = createLeafComponent<PixiMeshRope, Pixi.MeshRopeOptions>(PixiMeshRope);\n\n/**\n * A SolidJS component that renders a `PIXI.MeshSimple`.\n */\nexport const MeshSimple = createLeafComponent<PixiMeshSimple, Pixi.SimpleMeshOptions>(PixiMeshSimple);\n\n/**\n * A SolidJS component that renders a `PIXI.NineSliceSprite`.\n */\nexport const NineSliceSprite = createLeafComponent<PixiNineSliceSprite, Pixi.NineSliceSpriteOptions>(\n  PixiNineSliceSprite\n);\n\n/**\n * A SolidJS component that renders a `PIXI.ParticleContainer`.\n *\n * Particles should be added and removed from this component imperatively. Please see the docs for a reference example.\n */\nexport const ParticleContainer = createLeafComponent<PixiParticleContainer, Pixi.ParticleContainerOptions>(\n  PixiParticleContainer\n);\n\n/**\n * A SolidJS component that renders a `PIXI.PerspectiveMesh`.\n */\nexport const PerspectiveMesh = createLeafComponent<PixiPerspectiveMesh, Pixi.PerspectivePlaneOptions>(\n  PixiPerspectiveMesh\n);\n\n/**\n * A SolidJS component that renders a `PIXI.RenderContainer`.\n */\nexport const RenderContainer = createContainerComponent<PixiRenderContainer, Pixi.RenderContainerOptions>(\n  PixiRenderContainer\n);\n\n/**\n * A SolidJS component that renders a `PIXI.RenderLayer`.\n */\nexport const RenderLayer = createContainerComponent<PixiRenderLayer, Pixi.RenderLayerOptions>(PixiRenderLayer);\n\n/**\n * A SolidJS component that renders a `PIXI.Sprite`.\n */\nexport const Sprite = createLeafComponent<PixiSprite, Pixi.SpriteOptions>(PixiSprite);\n/**\n * A SolidJS component that renders a `PIXI.Text`.\n */\nexport const Text = createLeafComponent<PixiText, Pixi.CanvasTextOptions>(PixiText);\n\n/**\n * A SolidJS component that renders a `PIXI.TilingSprite`.\n */\nexport const TilingSprite = createLeafComponent<PixiTilingSprite, Pixi.TilingSpriteOptions>(PixiTilingSprite);\n\n// export const MeshGeometry = createLeafComponent<PixiMeshGeometry, Pixi.MeshGeometryOptions>(PixiMeshGeometry);\n\n// export const NineSliceGeometry = createLeafComponent<PixiNineSliceGeometry, Pixi.NineSliceGeometryOptions>(\n//   PixiNineSliceGeometry\n// );\n\n// export const Particle = createLeafComponent<PixiParticle, Pixi.ParticleOptions>(PixiParticle);\n\n// export const PerspectivePlaneGeometry = createLeafComponent<\n//   PixiPerspectivePlaneGeometry,\n//   Pixi.PerspectivePlaneGeometryOptions\n// >(PixiPerspectivePlaneGeometry);\n\n// export const PlaneGeometry = createLeafComponent<PixiPlaneGeometry, Pixi.PlaneGeometryOptions>(PixiPlaneGeometry);\n\n// export const RopeGeometry = createLeafComponent<PixiRopeGeometry, Pixi.RopeGeometryOptions>(PixiRopeGeometry);\n\n// TODO: Do we need a component for the Culler. It needs to interact with the stage directly.\n// export const Culler = createLeafComponent<PixiCuller, Pixi.Culler>(PixiCuller);\n"],"names":["SOLID_PROP_KEYS","applyProps","instance","props","defer","key","createRenderEffect","Error","insert","children","on","setProp","createContainerComponent","PixiClass","runtimeProps","initialisationProps","splitProps","PIXI_SOLID_EVENT_HANDLER_NAMES","as","createLeafComponent","AnimatedSprite","PixiAnimatedSprite","BitmapText","PixiBitmapText","Container","PixiContainer","Graphics","PixiGraphics","HTMLText","PixiHTMLText","MeshPlane","PixiMeshPlane","MeshRope","PixiMeshRope","MeshSimple","PixiMeshSimple","NineSliceSprite","PixiNineSliceSprite","ParticleContainer","PixiParticleContainer","PerspectiveMesh","PixiPerspectiveMesh","RenderContainer","PixiRenderContainer","RenderLayer","PixiRenderLayer","Sprite","PixiSprite","Text","PixiText","TilingSprite","PixiTilingSprite"],"mappings":";;;;AAyCO,MAAMA,IAAkB,CAAC,OAAO,MAAM,UAAU,GAW1CC,IAAa,CACxBC,GACAC,GACAC,MACG;AACH,aAAWC,KAAOF;AAChB,QAAIE,MAAQ;AAEZ,UAAIA,MAAQ;AACVC,QAAAA,EAAmB,MAAM;AAEtBH,UAAAA,EAAME,CAAG,EAAoCH,CAAQ;AAAA,QACxD,CAAC;AAAA,eACQG,MAAQ,YAAY;AAC7B,YAAI,EAAE,cAAcH;AAClB,gBAAM,IAAIK,MAAM,gDAAgD;AAElED,QAAAA,EAAmB,MAAM;AACvBE,UAAAA,EAAON,GAAU,MAAMC,EAAMM,QAAQ;AAAA,QACvC,CAAC;AAAA,MACH,OAAWL,IACTE,EACEI,EACE,MAAMP,EAAME,CAAyB,GACrC,MAAM;AACJM,QAAAA,EAAQT,GAAUG,GAAKF,EAAME,CAAyB,CAAC;AAAA,MACzD,GACA;AAAA,QAAED,OAAAA;AAAAA,MAAAA,CACJ,CACF,IAEAE,EAAmB,MAAM;AACvBK,QAAAA,EAAQT,GAAUG,GAAKF,EAAME,CAAyB,CAAC;AAAA,MACzD,CAAC;AAGP,GAEMO,IAA2B,CAC/BC,MAEO,CAACV,MAAqF;AAC3F,QAAM,CAACW,GAAcC,CAAmB,IAAIC,EAAWb,GAAO,CAC5D,GAAGH,GACH,GAAGiB,CAA8B,CAClC,GAEKf,IAAWC,EAAMe,MAAM,IAAIL,EAAUE,CAA0B;AAErEd,SAAAA,EAAWC,GAAUa,GAAqB,EAAI,GAC9Cd,EAAWC,GAAUY,CAAY,GAE1BZ;AACT,GAGIiB,IAAsB,CAC1BN,MAEO,CAACV,MACCS,EAAqDC,CAAS,EAAEV,CAAY,GAO1EiB,IAAiBD,EAAoEE,CAAkB,GAIvGC,IAAaH,EACxBI,CACF,GAIaC,IAAYZ,EAA+Da,CAAa,GAKxFC,IAAWP,EAAwDQ,CAAY,GAI/EC,IAAWT,EAAwDU,CAAY,GAK/EC,IAAYX,EAA0DY,CAAa,GAKnFC,IAAWb,EAAwDc,CAAY,GAK/EC,IAAaf,EAA4DgB,CAAc,GAKvFC,IAAkBjB,EAC7BkB,CACF,GAOaC,IAAoBnB,EAC/BoB,CACF,GAKaC,IAAkBrB,EAC7BsB,CACF,GAKaC,IAAkB9B,EAC7B+B,CACF,GAKaC,IAAchC,EAAmEiC,CAAe,GAKhGC,IAAS3B,EAAoD4B,CAAU,GAIvEC,IAAO7B,EAAsD8B,CAAQ,GAKrEC,IAAe/B,EAAgEgC,CAAgB;"}
+{"version":3,"file":"pixi-components.js","sources":["../src/pixi-components.tsx"],"sourcesContent":["import type * as Pixi from \"pixi.js\";\nimport {\n  AnimatedSprite as PixiAnimatedSprite,\n  BitmapText as PixiBitmapText,\n  Container as PixiContainer,\n  Graphics as PixiGraphics,\n  HTMLText as PixiHTMLText,\n  MeshPlane as PixiMeshPlane,\n  MeshRope as PixiMeshRope,\n  MeshSimple as PixiMeshSimple,\n  NineSliceSprite as PixiNineSliceSprite,\n  ParticleContainer as PixiParticleContainer,\n  PerspectiveMesh as PixiPerspectiveMesh,\n  RenderContainer as PixiRenderContainer,\n  RenderLayer as PixiRenderLayer,\n  Sprite as PixiSprite,\n  Text as PixiText,\n  TilingSprite as PixiTilingSprite,\n} from \"pixi.js\";\nimport type { JSX, Ref } from \"solid-js\";\nimport { createRenderEffect, on, splitProps } from \"solid-js\";\nimport type { PixiEventHandlerMap } from \"./pixi-events\";\n\nimport { PIXI_SOLID_EVENT_HANDLER_NAMES } from \"./pixi-events\";\nimport { insert, setProp } from \"./renderer\";\n\n/**\n * Prop definition for components that CAN have children\n */\nexport type ContainerProps<Component> = PixiEventHandlerMap & {\n  ref?: Ref<Component>;\n  as?: Component;\n  children?: JSX.Element;\n};\n\n/**\n * Prop definition for components that CANNOT have children\n */\nexport type LeafProps<Component> = Omit<ContainerProps<Component>, \"children\">;\n\n// Keys that are specific to Solid components and not Pixi props\nexport const SOLID_PROP_KEYS = [\"ref\", \"as\", \"children\"] as const;\n\n/**\n * Apply's the props to a Pixi instance with subsriptions to maintain reactivity.\n *\n * @param instance The Pixi instance we want to apply props to.\n * @param props The props object.\n * @param defer Defers the createRenderEffect so the props aren't set on the first run.\n * This is useful because setting initialisation props can have unintended side effects.\n * Notibly in AnimatedSprite, if we set the textures roperty after instantiation it will stop the instance from playing.\n */\nexport const applyProps = <InstanceType extends PixiContainer, OptionsType extends ContainerProps<InstanceType>>(\n  instance: InstanceType,\n  props: OptionsType,\n  defer?: boolean\n) => {\n  for (const key in props) {\n    if (key === \"as\") continue;\n\n    if (key === \"ref\") {\n      createRenderEffect(() => {\n        // Solid converts the ref prop to a callback function\n        (props[key] as unknown as (arg: any) => void)(instance);\n      });\n    } else if (key === \"children\") {\n      if (!(\"addChild\" in instance)) {\n        throw new Error(`Cannot set children on non-container instance.`);\n      }\n      createRenderEffect(() => {\n        insert(instance, () => props.children);\n      });\n    } else if (defer) {\n      createRenderEffect(\n        on(\n          () => props[key as keyof typeof props],\n          () => {\n            setProp(instance, key, props[key as keyof typeof props]);\n          },\n          { defer }\n        )\n      );\n    } else {\n      createRenderEffect(() => {\n        setProp(instance, key, props[key as keyof typeof props]);\n      });\n    }\n  }\n};\n\nconst createContainerComponent = <InstanceType extends PixiContainer, OptionsType extends object>(\n  PixiClass: new (props: OptionsType) => InstanceType\n) => {\n  return (props: Omit<OptionsType, \"children\"> & ContainerProps<InstanceType>): JSX.Element => {\n    const [runtimeProps, initialisationProps] = splitProps(props, [\n      ...SOLID_PROP_KEYS,\n      ...PIXI_SOLID_EVENT_HANDLER_NAMES,\n    ]);\n\n    const instance = props.as || new PixiClass(initialisationProps as any);\n\n    applyProps(instance, initialisationProps, true);\n    applyProps(instance, runtimeProps);\n\n    return instance as unknown as JSX.Element;\n  };\n};\n\nconst createLeafComponent = <InstanceType extends PixiContainer, OptionsType extends object>(\n  PixiClass: new (props: OptionsType) => InstanceType\n) => {\n  return (props: Omit<OptionsType, \"children\"> & LeafProps<InstanceType>): JSX.Element => {\n    return createContainerComponent<PixiContainer, OptionsType>(PixiClass)(props as any);\n  };\n};\n\n/**\n * A SolidJS component that renders a `PIXI.AnimatedSprite`.\n */\nexport const AnimatedSprite = createLeafComponent<PixiAnimatedSprite, Pixi.AnimatedSpriteOptions>(PixiAnimatedSprite);\n/**\n * A SolidJS component that renders a `PIXI.BitmapText`.\n */\nexport const BitmapText = createLeafComponent<PixiBitmapText, ConstructorParameters<typeof PixiBitmapText>>(\n  PixiBitmapText\n);\n/**\n * A SolidJS component that renders a `PIXI.Container`.\n */\nexport const Container = createContainerComponent<PixiContainer, Pixi.ContainerOptions>(PixiContainer);\n/**\n * A SolidJS component that renders a `PIXI.Graphics`.\n * Use a ref to access the underlying graphics instance and draw with it.\n */\nexport const Graphics = createLeafComponent<PixiGraphics, Pixi.GraphicsOptions>(PixiGraphics);\n/**\n * A SolidJS component that renders a `PIXI.HTMLText`.\n */\nexport const HTMLText = createLeafComponent<PixiHTMLText, Pixi.HTMLTextOptions>(PixiHTMLText);\n\n/**\n * A SolidJS component that renders a `PIXI.MeshPlane`.\n */\nexport const MeshPlane = createLeafComponent<PixiMeshPlane, Pixi.MeshPlaneOptions>(PixiMeshPlane);\n\n/**\n * A SolidJS component that renders a `PIXI.MeshRope`.\n */\nexport const MeshRope = createLeafComponent<PixiMeshRope, Pixi.MeshRopeOptions>(PixiMeshRope);\n\n/**\n * A SolidJS component that renders a `PIXI.MeshSimple`.\n */\nexport const MeshSimple = createLeafComponent<PixiMeshSimple, Pixi.SimpleMeshOptions>(PixiMeshSimple);\n\n/**\n * A SolidJS component that renders a `PIXI.NineSliceSprite`.\n */\nexport const NineSliceSprite = createLeafComponent<PixiNineSliceSprite, Pixi.NineSliceSpriteOptions>(\n  PixiNineSliceSprite\n);\n\n/**\n * A SolidJS component that renders a `PIXI.ParticleContainer`.\n *\n * Particles should be added and removed from this component imperatively. Please see the docs for a reference example.\n */\nexport const ParticleContainer = createLeafComponent<PixiParticleContainer, Pixi.ParticleContainerOptions>(\n  PixiParticleContainer\n);\n\n/**\n * A SolidJS component that renders a `PIXI.PerspectiveMesh`.\n */\nexport const PerspectiveMesh = createLeafComponent<PixiPerspectiveMesh, Pixi.PerspectivePlaneOptions>(\n  PixiPerspectiveMesh\n);\n\n/**\n * A SolidJS component that renders a `PIXI.RenderContainer`.\n */\nexport const RenderContainer = createContainerComponent<PixiRenderContainer, Pixi.RenderContainerOptions>(\n  PixiRenderContainer\n);\n\n/**\n * A SolidJS component that renders a `PIXI.RenderLayer`.\n */\nexport const RenderLayer = createContainerComponent<PixiRenderLayer, Pixi.RenderLayerOptions>(PixiRenderLayer);\n\n/**\n * A SolidJS component that renders a `PIXI.Sprite`.\n */\nexport const Sprite = createLeafComponent<PixiSprite, Pixi.SpriteOptions>(PixiSprite);\n/**\n * A SolidJS component that renders a `PIXI.Text`.\n */\nexport const Text = createLeafComponent<PixiText, Pixi.CanvasTextOptions>(PixiText);\n\n/**\n * A SolidJS component that renders a `PIXI.TilingSprite`.\n */\nexport const TilingSprite = createLeafComponent<PixiTilingSprite, Pixi.TilingSpriteOptions>(PixiTilingSprite);\n\n// export const MeshGeometry = createLeafComponent<PixiMeshGeometry, Pixi.MeshGeometryOptions>(PixiMeshGeometry);\n\n// export const NineSliceGeometry = createLeafComponent<PixiNineSliceGeometry, Pixi.NineSliceGeometryOptions>(\n//   PixiNineSliceGeometry\n// );\n\n// export const Particle = createLeafComponent<PixiParticle, Pixi.ParticleOptions>(PixiParticle);\n\n// export const PerspectivePlaneGeometry = createLeafComponent<\n//   PixiPerspectivePlaneGeometry,\n//   Pixi.PerspectivePlaneGeometryOptions\n// >(PixiPerspectivePlaneGeometry);\n\n// export const PlaneGeometry = createLeafComponent<PixiPlaneGeometry, Pixi.PlaneGeometryOptions>(PixiPlaneGeometry);\n\n// export const RopeGeometry = createLeafComponent<PixiRopeGeometry, Pixi.RopeGeometryOptions>(PixiRopeGeometry);\n\n// TODO: Do we need a component for the Culler. It needs to interact with the stage directly.\n// export const Culler = createLeafComponent<PixiCuller, Pixi.Culler>(PixiCuller);\n"],"names":["SOLID_PROP_KEYS","applyProps","instance","props","defer","key","createRenderEffect","Error","insert","children","on","setProp","createContainerComponent","PixiClass","runtimeProps","initialisationProps","splitProps","PIXI_SOLID_EVENT_HANDLER_NAMES","as","createLeafComponent","AnimatedSprite","PixiAnimatedSprite","BitmapText","PixiBitmapText","Container","PixiContainer","Graphics","PixiGraphics","HTMLText","PixiHTMLText","MeshPlane","PixiMeshPlane","MeshRope","PixiMeshRope","MeshSimple","PixiMeshSimple","NineSliceSprite","PixiNineSliceSprite","ParticleContainer","PixiParticleContainer","PerspectiveMesh","PixiPerspectiveMesh","RenderContainer","PixiRenderContainer","RenderLayer","PixiRenderLayer","Sprite","PixiSprite","Text","PixiText","TilingSprite","PixiTilingSprite"],"mappings":";;;;AAyCO,MAAMA,kBAAkB,CAAC,OAAO,MAAM,UAAU;AAWhD,MAAMC,aAAa,CACxBC,UACAC,OACAC,UACG;AACH,aAAWC,OAAOF,OAAO;AACvB,QAAIE,QAAQ,KAAM;AAElB,QAAIA,QAAQ,OAAO;AACjBC,yBAAmB,MAAM;AAEtBH,cAAME,GAAG,EAAoCH,QAAQ;AAAA,MACxD,CAAC;AAAA,IACH,WAAWG,QAAQ,YAAY;AAC7B,UAAI,EAAE,cAAcH,WAAW;AAC7B,cAAM,IAAIK,MAAM,gDAAgD;AAAA,MAClE;AACAD,yBAAmB,MAAM;AACvBE,eAAON,UAAU,MAAMC,MAAMM,QAAQ;AAAA,MACvC,CAAC;AAAA,IACH,WAAWL,OAAO;AAChBE,yBACEI,GACE,MAAMP,MAAME,GAAyB,GACrC,MAAM;AACJM,gBAAQT,UAAUG,KAAKF,MAAME,GAAyB,CAAC;AAAA,MACzD,GACA;AAAA,QAAED;AAAAA,MAAAA,CACJ,CACF;AAAA,IACF,OAAO;AACLE,yBAAmB,MAAM;AACvBK,gBAAQT,UAAUG,KAAKF,MAAME,GAAyB,CAAC;AAAA,MACzD,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAEA,MAAMO,2BAA2B,CAC/BC,cACG;AACH,SAAO,CAACV,UAAqF;AAC3F,UAAM,CAACW,cAAcC,mBAAmB,IAAIC,WAAWb,OAAO,CAC5D,GAAGH,iBACH,GAAGiB,8BAA8B,CAClC;AAED,UAAMf,WAAWC,MAAMe,MAAM,IAAIL,UAAUE,mBAA0B;AAErEd,eAAWC,UAAUa,qBAAqB,IAAI;AAC9Cd,eAAWC,UAAUY,YAAY;AAEjC,WAAOZ;AAAAA,EACT;AACF;AAEA,MAAMiB,sBAAsB,CAC1BN,cACG;AACH,SAAO,CAACV,UAAgF;AACtF,WAAOS,yBAAqDC,SAAS,EAAEV,KAAY;AAAA,EACrF;AACF;AAKO,MAAMiB,iBAAiBD,oBAAoEE,gBAAkB;AAI7G,MAAMC,aAAaH,oBACxBI,YACF;AAIO,MAAMC,YAAYZ,yBAA+Da,WAAa;AAK9F,MAAMC,WAAWP,oBAAwDQ,UAAY;AAIrF,MAAMC,WAAWT,oBAAwDU,UAAY;AAKrF,MAAMC,YAAYX,oBAA0DY,WAAa;AAKzF,MAAMC,WAAWb,oBAAwDc,UAAY;AAKrF,MAAMC,aAAaf,oBAA4DgB,YAAc;AAK7F,MAAMC,kBAAkBjB,oBAC7BkB,iBACF;AAOO,MAAMC,oBAAoBnB,oBAC/BoB,mBACF;AAKO,MAAMC,kBAAkBrB,oBAC7BsB,iBACF;AAKO,MAAMC,kBAAkB9B,yBAC7B+B,iBACF;AAKO,MAAMC,cAAchC,yBAAmEiC,aAAe;AAKtG,MAAMC,SAAS3B,oBAAoD4B,QAAU;AAI7E,MAAMC,OAAO7B,oBAAsD8B,MAAQ;AAK3E,MAAMC,eAAe/B,oBAAgEgC,cAAgB;"}

package/dist/pixi-events.js

@@ -1,4 +1,4 @@
-const t = [
+const PIXI_EVENT_NAMES = [
   "click",
   "mousedown",
   "mouseenter",
@@ -62,12 +62,14 @@ const t = [
   "touchmovecapture",
   "touchstartcapture",
   "wheelcapture"
-], o = t.map(
-  (e) => `on${e}`
-), u = new Set(o);
+];
+const PIXI_SOLID_EVENT_HANDLER_NAMES = PIXI_EVENT_NAMES.map(
+  (eventName) => `on${eventName}`
+);
+const PIXI_EVENT_HANDLER_NAME_SET = new Set(PIXI_SOLID_EVENT_HANDLER_NAMES);
 export {
-  u as PIXI_EVENT_HANDLER_NAME_SET,
-  t as PIXI_EVENT_NAMES,
-  o as PIXI_SOLID_EVENT_HANDLER_NAMES
+  PIXI_EVENT_HANDLER_NAME_SET,
+  PIXI_EVENT_NAMES,
+  PIXI_SOLID_EVENT_HANDLER_NAMES
 };
 //# sourceMappingURL=pixi-events.js.map

package/dist/pixi-events.js.map

@@ -1 +1 @@
-{"version":3,"file":"pixi-events.js","sources":["../src/pixi-events.ts"],"sourcesContent":["import type { FederatedEventEmitterTypes } from \"pixi.js\";\n\nexport const PIXI_EVENT_NAMES: (keyof FederatedEventEmitterTypes)[] = [\n  \"click\",\n  \"mousedown\",\n  \"mouseenter\",\n  \"mouseleave\",\n  \"mousemove\",\n  \"mouseout\",\n  \"mouseover\",\n  \"mouseup\",\n  \"mouseupoutside\",\n  \"pointercancel\",\n  \"pointerdown\",\n  \"pointerenter\",\n  \"pointerleave\",\n  \"pointermove\",\n  \"pointerout\",\n  \"pointerover\",\n  \"pointertap\",\n  \"pointerup\",\n  \"pointerupoutside\",\n  \"rightclick\",\n  \"rightdown\",\n  \"rightup\",\n  \"rightupoutside\",\n  \"tap\",\n  \"touchcancel\",\n  \"touchend\",\n  \"touchendoutside\",\n  \"touchmove\",\n  \"touchstart\",\n  \"wheel\",\n  \"globalmousemove\",\n  \"globalpointermove\",\n  \"globaltouchmove\",\n  \"clickcapture\",\n  \"mousedowncapture\",\n  \"mouseentercapture\",\n  \"mouseleavecapture\",\n  \"mousemovecapture\",\n  \"mouseoutcapture\",\n  \"mouseovercapture\",\n  \"mouseupcapture\",\n  \"mouseupoutsidecapture\",\n  \"pointercancelcapture\",\n  \"pointerdowncapture\",\n  \"pointerentercapture\",\n  \"pointerleavecapture\",\n  \"pointermovecapture\",\n  \"pointeroutcapture\",\n  \"pointerovercapture\",\n  \"pointertapcapture\",\n  \"pointerupcapture\",\n  \"pointerupoutsidecapture\",\n  \"rightclickcapture\",\n  \"rightdowncapture\",\n  \"rightupcapture\",\n  \"rightupoutsidecapture\",\n  \"tapcapture\",\n  \"touchcancelcapture\",\n  \"touchendcapture\",\n  \"touchendoutsidecapture\",\n  \"touchmovecapture\",\n  \"touchstartcapture\",\n  \"wheelcapture\",\n] as const;\n\nexport const PIXI_SOLID_EVENT_HANDLER_NAMES = PIXI_EVENT_NAMES.map(\n  (eventName) => `on${eventName}` as const,\n);\n\nexport type PixiEventHandlerMap = {\n  [K in (typeof PIXI_EVENT_NAMES)[number] as `on${K}`]?:\n    | null\n    | ((...args: FederatedEventEmitterTypes[K]) => void);\n};\n\nexport const PIXI_EVENT_HANDLER_NAME_SET: Readonly<\n  Set<(typeof PIXI_SOLID_EVENT_HANDLER_NAMES)[number]>\n> = new Set(PIXI_SOLID_EVENT_HANDLER_NAMES);\n\n/**\n * This is a type-safe check that ensures `PIXI_EVENT_NAMES` includes every key from Pixi's `AllFederatedEventMap` type.\n * It will cause a build error if any event names are missing.\n */\ntype MissingKeys = Exclude<keyof FederatedEventEmitterTypes, (typeof PIXI_EVENT_NAMES)[number]>;\ntype AllEventsAreHandled = MissingKeys extends never\n  ? true\n  : `Error: Missing event keys: ${MissingKeys}`;\nconst allEventsAreHandled: AllEventsAreHandled = true;\nvoid allEventsAreHandled;\n"],"names":["PIXI_EVENT_NAMES","PIXI_SOLID_EVENT_HANDLER_NAMES","eventName","PIXI_EVENT_HANDLER_NAME_SET"],"mappings":"AAEO,MAAMA,IAAyD;AAAA,EACpE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAEaC,IAAiCD,EAAiB;AAAA,EAC7D,CAACE,MAAc,KAAKA,CAAS;AAC/B,GAQaC,IAET,IAAI,IAAIF,CAA8B;"}
+{"version":3,"file":"pixi-events.js","sources":["../src/pixi-events.ts"],"sourcesContent":["import type { FederatedEventEmitterTypes } from \"pixi.js\";\n\nexport const PIXI_EVENT_NAMES: (keyof FederatedEventEmitterTypes)[] = [\n  \"click\",\n  \"mousedown\",\n  \"mouseenter\",\n  \"mouseleave\",\n  \"mousemove\",\n  \"mouseout\",\n  \"mouseover\",\n  \"mouseup\",\n  \"mouseupoutside\",\n  \"pointercancel\",\n  \"pointerdown\",\n  \"pointerenter\",\n  \"pointerleave\",\n  \"pointermove\",\n  \"pointerout\",\n  \"pointerover\",\n  \"pointertap\",\n  \"pointerup\",\n  \"pointerupoutside\",\n  \"rightclick\",\n  \"rightdown\",\n  \"rightup\",\n  \"rightupoutside\",\n  \"tap\",\n  \"touchcancel\",\n  \"touchend\",\n  \"touchendoutside\",\n  \"touchmove\",\n  \"touchstart\",\n  \"wheel\",\n  \"globalmousemove\",\n  \"globalpointermove\",\n  \"globaltouchmove\",\n  \"clickcapture\",\n  \"mousedowncapture\",\n  \"mouseentercapture\",\n  \"mouseleavecapture\",\n  \"mousemovecapture\",\n  \"mouseoutcapture\",\n  \"mouseovercapture\",\n  \"mouseupcapture\",\n  \"mouseupoutsidecapture\",\n  \"pointercancelcapture\",\n  \"pointerdowncapture\",\n  \"pointerentercapture\",\n  \"pointerleavecapture\",\n  \"pointermovecapture\",\n  \"pointeroutcapture\",\n  \"pointerovercapture\",\n  \"pointertapcapture\",\n  \"pointerupcapture\",\n  \"pointerupoutsidecapture\",\n  \"rightclickcapture\",\n  \"rightdowncapture\",\n  \"rightupcapture\",\n  \"rightupoutsidecapture\",\n  \"tapcapture\",\n  \"touchcancelcapture\",\n  \"touchendcapture\",\n  \"touchendoutsidecapture\",\n  \"touchmovecapture\",\n  \"touchstartcapture\",\n  \"wheelcapture\",\n] as const;\n\nexport const PIXI_SOLID_EVENT_HANDLER_NAMES = PIXI_EVENT_NAMES.map(\n  (eventName) => `on${eventName}` as const,\n);\n\nexport type PixiEventHandlerMap = {\n  [K in (typeof PIXI_EVENT_NAMES)[number] as `on${K}`]?:\n    | null\n    | ((...args: FederatedEventEmitterTypes[K]) => void);\n};\n\nexport const PIXI_EVENT_HANDLER_NAME_SET: Readonly<\n  Set<(typeof PIXI_SOLID_EVENT_HANDLER_NAMES)[number]>\n> = new Set(PIXI_SOLID_EVENT_HANDLER_NAMES);\n\n/**\n * This is a type-safe check that ensures `PIXI_EVENT_NAMES` includes every key from Pixi's `AllFederatedEventMap` type.\n * It will cause a build error if any event names are missing.\n */\ntype MissingKeys = Exclude<keyof FederatedEventEmitterTypes, (typeof PIXI_EVENT_NAMES)[number]>;\ntype AllEventsAreHandled = MissingKeys extends never\n  ? true\n  : `Error: Missing event keys: ${MissingKeys}`;\nconst allEventsAreHandled: AllEventsAreHandled = true;\nvoid allEventsAreHandled;\n"],"names":[],"mappings":"AAEO,MAAM,mBAAyD;AAAA,EACpE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAEO,MAAM,iCAAiC,iBAAiB;AAAA,EAC7D,CAAC,cAAc,KAAK,SAAS;AAC/B;AAQO,MAAM,8BAET,IAAI,IAAI,8BAA8B;"}

package/dist/pixi-stage.js

@@ -1,11 +1,12 @@
-import { memo as r } from "solid-js/web";
-import { usePixiApp as t } from "./pixi-application.js";
-import { applyProps as i } from "./pixi-components.js";
-const a = (o) => {
-  const p = t();
-  return i(p.stage, o), r(() => p.stage);
+import { memo } from "solid-js/web";
+import { usePixiApp } from "./pixi-application.js";
+import { applyProps } from "./pixi-components.js";
+const PixiStage = (props) => {
+  const pixiApp = usePixiApp();
+  applyProps(pixiApp.stage, props);
+  return memo(() => pixiApp.stage);
 };
 export {
-  a as PixiStage
+  PixiStage
 };
 //# sourceMappingURL=pixi-stage.js.map

package/dist/pixi-stage.js.map

@@ -1 +1 @@
-{"version":3,"file":"pixi-stage.js","sources":["../src/pixi-stage.tsx"],"sourcesContent":["import type { Container, ContainerOptions } from \"pixi.js\";\nimport type { JSX, Ref } from \"solid-js\";\nimport { usePixiApp } from \"./pixi-application\";\nimport { applyProps } from \"./pixi-components\";\nimport type { PixiEventHandlerMap } from \"./pixi-events\";\n\nexport type PixiStageProps = PixiEventHandlerMap &\n  Omit<ContainerOptions, \"children\"> & {\n    ref?: Ref<Container>;\n    children?: JSX.Element;\n  };\n\n/**\n * PixiStage\n *\n * The root container for rendering Pixi display objects. This component\n * uses the application stage (`pixiApp.stage`) as the mount point and\n * applies props and event handlers to it.\n *\n * Props:\n * - `ref` (optional): receives the stage container reference.\n * - Event handler props (e.g. `onpointerdown`) are forwarded to the stage.\n * - Any other container options supported by Pixi may be passed.\n *\n * Children passed to `PixiStage` are inserted into the application stage.\n */\nexport const PixiStage = (props: PixiStageProps): JSX.Element => {\n  const pixiApp = usePixiApp();\n\n  applyProps(pixiApp.stage, props);\n\n  return <>{pixiApp.stage}</>;\n};\n"],"names":["PixiStage","props","pixiApp","usePixiApp","applyProps","stage","_$memo"],"mappings":";;;AA0BO,MAAMA,IAAYA,CAACC,MAAuC;AAC/D,QAAMC,IAAUC,EAAAA;AAEhBC,SAAAA,EAAWF,EAAQG,OAAOJ,CAAK,GAE/BK,EAAA,MAAUJ,EAAQG,KAAK;AACzB;"}
+{"version":3,"file":"pixi-stage.js","sources":["../src/pixi-stage.tsx"],"sourcesContent":["import type { Container, ContainerOptions } from \"pixi.js\";\nimport type { JSX, Ref } from \"solid-js\";\nimport { usePixiApp } from \"./pixi-application\";\nimport { applyProps } from \"./pixi-components\";\nimport type { PixiEventHandlerMap } from \"./pixi-events\";\n\nexport type PixiStageProps = PixiEventHandlerMap &\n  Omit<ContainerOptions, \"children\"> & {\n    ref?: Ref<Container>;\n    children?: JSX.Element;\n  };\n\n/**\n * PixiStage\n *\n * The root container for rendering Pixi display objects. This component\n * uses the application stage (`pixiApp.stage`) as the mount point and\n * applies props and event handlers to it.\n *\n * Props:\n * - `ref` (optional): receives the stage container reference.\n * - Event handler props (e.g. `onpointerdown`) are forwarded to the stage.\n * - Any other container options supported by Pixi may be passed.\n *\n * Children passed to `PixiStage` are inserted into the application stage.\n */\nexport const PixiStage = (props: PixiStageProps): JSX.Element => {\n  const pixiApp = usePixiApp();\n\n  applyProps(pixiApp.stage, props);\n\n  return <>{pixiApp.stage}</>;\n};\n"],"names":["PixiStage","props","pixiApp","usePixiApp","applyProps","stage","_$memo"],"mappings":";;;AA0BO,MAAMA,YAAYA,CAACC,UAAuC;AAC/D,QAAMC,UAAUC,WAAAA;AAEhBC,aAAWF,QAAQG,OAAOJ,KAAK;AAE/B,SAAAK,KAAA,MAAUJ,QAAQG,KAAK;AACzB;"}

package/dist/renderer.js

@@ -1,83 +1,92 @@
-import { Text as o } from "pixi.js";
-import { createRenderer as d } from "solid-js/universal";
-import { PIXI_EVENT_HANDLER_NAME_SET as c } from "./pixi-events.js";
+import { Text } from "pixi.js";
+import { createRenderer } from "solid-js/universal";
+import { PIXI_EVENT_HANDLER_NAME_SET } from "./pixi-events.js";
 const {
-  effect: f,
-  memo: h,
-  createComponent: m,
-  createElement: u,
-  createTextNode: p,
-  insertNode: x,
-  insert: N,
-  setProp: E,
-  mergeProps: C,
-  use: P,
-  render: v,
-  spread: T
-} = d({
-  createElement(e) {
-    throw new Error(`Cannot create element "${e}". Please import components directly from 'pixi-solid' and use them with a capital letter.`);
+  effect,
+  memo,
+  createComponent,
+  createElement,
+  createTextNode,
+  insertNode,
+  insert,
+  setProp,
+  mergeProps,
+  use,
+  render,
+  spread
+} = createRenderer({
+  createElement(name) {
+    throw new Error(`Cannot create element "${name}". Please import components directly from 'pixi-solid' and use them with a capital letter.`);
   },
-  createTextNode(e) {
-    return new o({
-      text: e
+  createTextNode(value) {
+    return new Text({
+      text: value
     });
   },
-  replaceText(e, t) {
-    e.text = t;
+  replaceText(textNode, value) {
+    textNode.text = value;
   },
-  setProperty(e, t, r, i) {
-    if (c.has(t)) {
-      const n = t.slice(2);
-      i && e.removeEventListener(n, i), e.addEventListener(n, r);
+  setProperty(node, name, value, prev) {
+    if (PIXI_EVENT_HANDLER_NAME_SET.has(name)) {
+      const eventName = name.slice(2);
+      if (prev) {
+        node.removeEventListener(eventName, prev);
+      }
+      node.addEventListener(eventName, value);
       return;
     }
-    if (t in e) {
-      e[t] = r;
+    if (name in node) {
+      node[name] = value;
       return;
     }
   },
-  insertNode(e, t, r) {
-    if ("attach" in e && typeof e.attach == "function") {
-      e.attach(t);
+  insertNode(parent, node, anchor) {
+    if ("attach" in parent && typeof parent.attach === "function") {
+      parent.attach(node);
       return;
     }
-    if (!("addChildAt" in e) || !("addChild" in e) || typeof e.addChild != "function")
+    if (!("addChildAt" in parent) || !("addChild" in parent) || typeof parent.addChild !== "function") {
       throw new Error("Parent does not support children.");
-    r ? e.addChildAt(t, e.children.indexOf(r)) : e.addChild(t);
+    }
+    if (anchor) {
+      parent.addChildAt(node, parent.children.indexOf(anchor));
+    } else {
+      parent.addChild(node);
+    }
   },
-  isTextNode(e) {
-    return e instanceof o;
+  isTextNode(node) {
+    return node instanceof Text;
   },
-  removeNode(e, t) {
-    t.removeFromParent(), t.destroy({
-      children: !0
+  removeNode(_, node) {
+    node.removeFromParent();
+    node.destroy({
+      children: true
     });
   },
-  getParentNode(e) {
-    return e?.parent ?? void 0;
+  getParentNode(node) {
+    return node?.parent ?? void 0;
   },
-  getFirstChild(e) {
-    return e.children?.[0];
+  getFirstChild(node) {
+    return node.children?.[0];
   },
-  getNextSibling(e) {
-    if (!e.parent) return;
-    const t = e.parent.children.indexOf(e);
-    return t > -1 ? e.parent.children[t + 1] : void 0;
+  getNextSibling(node) {
+    if (!node.parent) return void 0;
+    const index = node.parent.children.indexOf(node);
+    return index > -1 ? node.parent.children[index + 1] : void 0;
   }
 });
 export {
-  m as createComponent,
-  u as createElement,
-  p as createTextNode,
-  f as effect,
-  N as insert,
-  x as insertNode,
-  h as memo,
-  C as mergeProps,
-  v as render,
-  E as setProp,
-  T as spread,
-  P as use
+  createComponent,
+  createElement,
+  createTextNode,
+  effect,
+  insert,
+  insertNode,
+  memo,
+  mergeProps,
+  render,
+  setProp,
+  spread,
+  use
 };
 //# sourceMappingURL=renderer.js.map

package/dist/renderer.js.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.js","sources":["../src/renderer.tsx"],"sourcesContent":["import type { Container as PixiContainer } from \"pixi.js\";\nimport { Text as PixiText } from \"pixi.js\";\nimport { createRenderer } from \"solid-js/universal\";\nimport type { PIXI_EVENT_NAMES, PixiEventHandlerMap } from \"./pixi-events\";\nimport { PIXI_EVENT_HANDLER_NAME_SET } from \"./pixi-events\";\n\nexport const {\n  effect,\n  memo,\n  createComponent,\n  createElement,\n  createTextNode,\n  insertNode,\n  insert,\n  setProp,\n  mergeProps,\n  use,\n  render,\n  spread,\n} = createRenderer<PixiContainer>({\n  createElement(name: string) {\n    // This function is for lowercase string tags like `<container />`.\n    // To support tree-shaking, we require users to import components\n    // directly and use them with an uppercase name like `<Container />`,\n    // which does not call this function.\n    throw new Error(\n      `Cannot create element \"${name}\". Please import components directly from 'pixi-solid' and use them with a capital letter.`,\n    );\n  },\n  createTextNode(value) {\n    return new PixiText({ text: value });\n  },\n  replaceText(textNode: PixiText, value) {\n    textNode.text = value;\n  },\n  setProperty(node, name, value, prev) {\n    // Check for event listeners and handle them appropriately.\n    if (PIXI_EVENT_HANDLER_NAME_SET.has(name as keyof PixiEventHandlerMap)) {\n      // Remove the 'on' prefix to get the actual event name.\n      const eventName = name.slice(2) as (typeof PIXI_EVENT_NAMES)[number];\n\n      if (prev) {\n        node.removeEventListener(eventName, prev as any);\n      }\n      node.addEventListener(eventName, value as any);\n      return;\n    }\n\n    if (name in node) {\n      (node as any)[name] = value;\n      return;\n    }\n  },\n  insertNode(parent, node, anchor) {\n    // RenderLayer uses `attach` instead of `addChild`.\n    if (\"attach\" in parent && typeof parent.attach === \"function\") {\n      parent.attach(node);\n      // Note: `attach` does not support anchoring, so we ignore the anchor.\n      return;\n    }\n\n    if (\n      !(\"addChildAt\" in parent) ||\n      !(\"addChild\" in parent) ||\n      typeof parent.addChild !== \"function\"\n    ) {\n      throw new Error(\"Parent does not support children.\");\n    }\n\n    if (anchor) {\n      parent.addChildAt(node, parent.children.indexOf(anchor));\n    } else {\n      parent.addChild(node);\n    }\n  },\n  isTextNode(node) {\n    return node instanceof PixiText;\n  },\n  removeNode(_, node) {\n    node.removeFromParent();\n    node.destroy({ children: true });\n  },\n  getParentNode(node) {\n    return node?.parent ?? undefined;\n  },\n  getFirstChild(node) {\n    return node.children?.[0];\n  },\n  getNextSibling(node) {\n    if (!node.parent) return undefined;\n    const index = node.parent.children.indexOf(node);\n    // Return the next child if it exists, otherwise undefined.\n    return index > -1 ? node.parent.children[index + 1] : undefined;\n  },\n});\n"],"names":["effect","memo","createComponent","createElement","createTextNode","insertNode","insert","setProp","mergeProps","use","render","spread","createRenderer","name","Error","value","PixiText","text","replaceText","textNode","setProperty","node","prev","PIXI_EVENT_HANDLER_NAME_SET","has","eventName","slice","removeEventListener","addEventListener","parent","anchor","attach","addChild","addChildAt","children","indexOf","isTextNode","removeNode","_","removeFromParent","destroy","getParentNode","undefined","getFirstChild","getNextSibling","index"],"mappings":";;;AAMO,MAAM;AAAA,EACXA,QAAAA;AAAAA,EACAC,MAAAA;AAAAA,EACAC,iBAAAA;AAAAA,EACAC,eAAAA;AAAAA,EACAC,gBAAAA;AAAAA,EACAC,YAAAA;AAAAA,EACAC,QAAAA;AAAAA,EACAC,SAAAA;AAAAA,EACAC,YAAAA;AAAAA,EACAC,KAAAA;AAAAA,EACAC,QAAAA;AAAAA,EACAC,QAAAA;AACF,IAAIC,EAA8B;AAAA,EAChCT,cAAcU,GAAc;AAK1B,UAAM,IAAIC,MACR,0BAA0BD,CAAI,4FAChC;AAAA,EACF;AAAA,EACAT,eAAeW,GAAO;AACpB,WAAO,IAAIC,EAAS;AAAA,MAAEC,MAAMF;AAAAA,IAAAA,CAAO;AAAA,EACrC;AAAA,EACAG,YAAYC,GAAoBJ,GAAO;AACrCI,IAAAA,EAASF,OAAOF;AAAAA,EAClB;AAAA,EACAK,YAAYC,GAAMR,GAAME,GAAOO,GAAM;AAEnC,QAAIC,EAA4BC,IAAIX,CAAiC,GAAG;AAEtE,YAAMY,IAAYZ,EAAKa,MAAM,CAAC;AAE9B,MAAIJ,KACFD,EAAKM,oBAAoBF,GAAWH,CAAW,GAEjDD,EAAKO,iBAAiBH,GAAWV,CAAY;AAC7C;AAAA,IACF;AAEA,QAAIF,KAAQQ,GAAM;AACfA,MAAAA,EAAaR,CAAI,IAAIE;AACtB;AAAA,IACF;AAAA,EACF;AAAA,EACAV,WAAWwB,GAAQR,GAAMS,GAAQ;AAE/B,QAAI,YAAYD,KAAU,OAAOA,EAAOE,UAAW,YAAY;AAC7DF,MAAAA,EAAOE,OAAOV,CAAI;AAElB;AAAA,IACF;AAEA,QACE,EAAE,gBAAgBQ,MAClB,EAAE,cAAcA,MAChB,OAAOA,EAAOG,YAAa;AAE3B,YAAM,IAAIlB,MAAM,mCAAmC;AAGrD,IAAIgB,IACFD,EAAOI,WAAWZ,GAAMQ,EAAOK,SAASC,QAAQL,CAAM,CAAC,IAEvDD,EAAOG,SAASX,CAAI;AAAA,EAExB;AAAA,EACAe,WAAWf,GAAM;AACf,WAAOA,aAAgBL;AAAAA,EACzB;AAAA,EACAqB,WAAWC,GAAGjB,GAAM;AAClBA,IAAAA,EAAKkB,iBAAAA,GACLlB,EAAKmB,QAAQ;AAAA,MAAEN,UAAU;AAAA,IAAA,CAAM;AAAA,EACjC;AAAA,EACAO,cAAcpB,GAAM;AAClB,WAAOA,GAAMQ,UAAUa;AAAAA,EACzB;AAAA,EACAC,cAActB,GAAM;AAClB,WAAOA,EAAKa,WAAW,CAAC;AAAA,EAC1B;AAAA,EACAU,eAAevB,GAAM;AACnB,QAAI,CAACA,EAAKQ,OAAQ;AAClB,UAAMgB,IAAQxB,EAAKQ,OAAOK,SAASC,QAAQd,CAAI;AAE/C,WAAOwB,IAAQ,KAAKxB,EAAKQ,OAAOK,SAASW,IAAQ,CAAC,IAAIH;AAAAA,EACxD;AACF,CAAC;"}
+{"version":3,"file":"renderer.js","sources":["../src/renderer.tsx"],"sourcesContent":["import type { Container as PixiContainer } from \"pixi.js\";\nimport { Text as PixiText } from \"pixi.js\";\nimport { createRenderer } from \"solid-js/universal\";\nimport type { PIXI_EVENT_NAMES, PixiEventHandlerMap } from \"./pixi-events\";\nimport { PIXI_EVENT_HANDLER_NAME_SET } from \"./pixi-events\";\n\nexport const {\n  effect,\n  memo,\n  createComponent,\n  createElement,\n  createTextNode,\n  insertNode,\n  insert,\n  setProp,\n  mergeProps,\n  use,\n  render,\n  spread,\n} = createRenderer<PixiContainer>({\n  createElement(name: string) {\n    // This function is for lowercase string tags like `<container />`.\n    // To support tree-shaking, we require users to import components\n    // directly and use them with an uppercase name like `<Container />`,\n    // which does not call this function.\n    throw new Error(\n      `Cannot create element \"${name}\". Please import components directly from 'pixi-solid' and use them with a capital letter.`,\n    );\n  },\n  createTextNode(value) {\n    return new PixiText({ text: value });\n  },\n  replaceText(textNode: PixiText, value) {\n    textNode.text = value;\n  },\n  setProperty(node, name, value, prev) {\n    // Check for event listeners and handle them appropriately.\n    if (PIXI_EVENT_HANDLER_NAME_SET.has(name as keyof PixiEventHandlerMap)) {\n      // Remove the 'on' prefix to get the actual event name.\n      const eventName = name.slice(2) as (typeof PIXI_EVENT_NAMES)[number];\n\n      if (prev) {\n        node.removeEventListener(eventName, prev as any);\n      }\n      node.addEventListener(eventName, value as any);\n      return;\n    }\n\n    if (name in node) {\n      (node as any)[name] = value;\n      return;\n    }\n  },\n  insertNode(parent, node, anchor) {\n    // RenderLayer uses `attach` instead of `addChild`.\n    if (\"attach\" in parent && typeof parent.attach === \"function\") {\n      parent.attach(node);\n      // Note: `attach` does not support anchoring, so we ignore the anchor.\n      return;\n    }\n\n    if (\n      !(\"addChildAt\" in parent) ||\n      !(\"addChild\" in parent) ||\n      typeof parent.addChild !== \"function\"\n    ) {\n      throw new Error(\"Parent does not support children.\");\n    }\n\n    if (anchor) {\n      parent.addChildAt(node, parent.children.indexOf(anchor));\n    } else {\n      parent.addChild(node);\n    }\n  },\n  isTextNode(node) {\n    return node instanceof PixiText;\n  },\n  removeNode(_, node) {\n    node.removeFromParent();\n    node.destroy({ children: true });\n  },\n  getParentNode(node) {\n    return node?.parent ?? undefined;\n  },\n  getFirstChild(node) {\n    return node.children?.[0];\n  },\n  getNextSibling(node) {\n    if (!node.parent) return undefined;\n    const index = node.parent.children.indexOf(node);\n    // Return the next child if it exists, otherwise undefined.\n    return index > -1 ? node.parent.children[index + 1] : undefined;\n  },\n});\n"],"names":["effect","memo","createComponent","createElement","createTextNode","insertNode","insert","setProp","mergeProps","use","render","spread","createRenderer","name","Error","value","PixiText","text","replaceText","textNode","setProperty","node","prev","PIXI_EVENT_HANDLER_NAME_SET","has","eventName","slice","removeEventListener","addEventListener","parent","anchor","attach","addChild","addChildAt","children","indexOf","isTextNode","removeNode","_","removeFromParent","destroy","getParentNode","undefined","getFirstChild","getNextSibling","index"],"mappings":";;;AAMO,MAAM;AAAA,EACXA;AAAAA,EACAC;AAAAA,EACAC;AAAAA,EACAC;AAAAA,EACAC;AAAAA,EACAC;AAAAA,EACAC;AAAAA,EACAC;AAAAA,EACAC;AAAAA,EACAC;AAAAA,EACAC;AAAAA,EACAC;AACF,IAAIC,eAA8B;AAAA,EAChCT,cAAcU,MAAc;AAK1B,UAAM,IAAIC,MACR,0BAA0BD,IAAI,4FAChC;AAAA,EACF;AAAA,EACAT,eAAeW,OAAO;AACpB,WAAO,IAAIC,KAAS;AAAA,MAAEC,MAAMF;AAAAA,IAAAA,CAAO;AAAA,EACrC;AAAA,EACAG,YAAYC,UAAoBJ,OAAO;AACrCI,aAASF,OAAOF;AAAAA,EAClB;AAAA,EACAK,YAAYC,MAAMR,MAAME,OAAOO,MAAM;AAEnC,QAAIC,4BAA4BC,IAAIX,IAAiC,GAAG;AAEtE,YAAMY,YAAYZ,KAAKa,MAAM,CAAC;AAE9B,UAAIJ,MAAM;AACRD,aAAKM,oBAAoBF,WAAWH,IAAW;AAAA,MACjD;AACAD,WAAKO,iBAAiBH,WAAWV,KAAY;AAC7C;AAAA,IACF;AAEA,QAAIF,QAAQQ,MAAM;AACfA,WAAaR,IAAI,IAAIE;AACtB;AAAA,IACF;AAAA,EACF;AAAA,EACAV,WAAWwB,QAAQR,MAAMS,QAAQ;AAE/B,QAAI,YAAYD,UAAU,OAAOA,OAAOE,WAAW,YAAY;AAC7DF,aAAOE,OAAOV,IAAI;AAElB;AAAA,IACF;AAEA,QACE,EAAE,gBAAgBQ,WAClB,EAAE,cAAcA,WAChB,OAAOA,OAAOG,aAAa,YAC3B;AACA,YAAM,IAAIlB,MAAM,mCAAmC;AAAA,IACrD;AAEA,QAAIgB,QAAQ;AACVD,aAAOI,WAAWZ,MAAMQ,OAAOK,SAASC,QAAQL,MAAM,CAAC;AAAA,IACzD,OAAO;AACLD,aAAOG,SAASX,IAAI;AAAA,IACtB;AAAA,EACF;AAAA,EACAe,WAAWf,MAAM;AACf,WAAOA,gBAAgBL;AAAAA,EACzB;AAAA,EACAqB,WAAWC,GAAGjB,MAAM;AAClBA,SAAKkB,iBAAAA;AACLlB,SAAKmB,QAAQ;AAAA,MAAEN,UAAU;AAAA,IAAA,CAAM;AAAA,EACjC;AAAA,EACAO,cAAcpB,MAAM;AAClB,WAAOA,MAAMQ,UAAUa;AAAAA,EACzB;AAAA,EACAC,cAActB,MAAM;AAClB,WAAOA,KAAKa,WAAW,CAAC;AAAA,EAC1B;AAAA,EACAU,eAAevB,MAAM;AACnB,QAAI,CAACA,KAAKQ,OAAQ,QAAOa;AACzB,UAAMG,QAAQxB,KAAKQ,OAAOK,SAASC,QAAQd,IAAI;AAE/C,WAAOwB,QAAQ,KAAKxB,KAAKQ,OAAOK,SAASW,QAAQ,CAAC,IAAIH;AAAAA,EACxD;AACF,CAAC;"}

package/dist/types/index.d.ts

@@ -1,5 +1,5 @@
 export type { PixiApplicationProps } from "./pixi-application";
-export { PixiApplication, usePixiApp } from "./pixi-application";
+export { PixiApplication, TickerProvider, usePixiApp, useTick, useTicker, } from "./pixi-application";
 export { PixiCanvas } from "./pixi-canvas";
 export type { ContainerProps, LeafProps } from "./pixi-components";
 export { AnimatedSprite, BitmapText, Container, Graphics, HTMLText, MeshPlane, MeshRope, MeshSimple, NineSliceSprite, ParticleContainer, PerspectiveMesh, RenderContainer, RenderLayer, Sprite, Text, TilingSprite, } from "./pixi-components";
@@ -8,4 +8,3 @@ export { PIXI_EVENT_NAMES, PIXI_SOLID_EVENT_HANDLER_NAMES } from "./pixi-events"
 export type { PixiStageProps } from "./pixi-stage";
 export { PixiStage } from "./pixi-stage";
 export { useResize } from "./use-resize";
-export { useTick, useTicker } from "./use-ticker";

package/dist/types/pixi-application.d.ts

@@ -1,6 +1,6 @@
-import type { ApplicationOptions } from "pixi.js";
+import type { ApplicationOptions, Ticker, TickerCallback } from "pixi.js";
 import { Application } from "pixi.js";
-import type { JSX, Ref } from "solid-js";
+import type { JSX, ParentProps, Ref } from "solid-js";
 /**
  * A custom SolidJS hook to access the root PIXI.Application instance.
  * This hook must be called from a component that is a descendant of `PixiApplication`.
@@ -29,3 +29,39 @@ export type PixiApplicationProps = Partial<Omit<ApplicationOptions, "children" |
  *
  */
 export declare const PixiApplication: (props: PixiApplicationProps) => JSX.Element;
+export type TickerProviderProps = ParentProps<{
+    ticker: Ticker;
+}>;
+/**
+ * This is only required if you want a ticker without the Application.
+ * It provides context for the `useTick` and `useTicker` hooks so we can run tests that use them without having to instantate a Pixi Application.
+ *
+ * You need to pass in the ticker instance you want to use so it can be manually controled form the outside for testing.
+ */
+export declare const TickerProvider: (props: TickerProviderProps) => JSX.Element;
+/**
+ * useTicker
+ *
+ * A custom SolidJS hook that provides access to the PIXI.Application's shared Ticker instance.
+ * This hook must be called from a component that is a descendant of `PixiApplication`.
+ * Or a descendant of `TickerProvider` if being used for testing without an application.
+ *
+ * @returns The PIXI.Ticker instance from the application context.
+ * @throws Will throw an error if used outside of a `PixiApplication` or `TickerProvider` context.
+ */
+export declare const useTicker: () => Ticker;
+/**
+ * useTick
+ *
+ * A custom SolidJS hook that registers a callback function to be executed on every frame
+ * of the PIXI.Application's ticker. The callback is automatically removed when the
+ * component or hook's owning computation is cleaned up.
+ *
+ * This hook must be called from a component that is a descendant of `PixiApplication`.
+ * Or a descendant of `TickerProvider` if being used for testing without an application.
+ *
+ * @param tickerCallback - The function to call on each ticker update. It receives
+ * the `PIXI.Ticker` instance as its argument.
+ *
+ */
+export declare const useTick: (tickerCallback: TickerCallback<Ticker>) => void;

package/dist/use-resize.js

@@ -1,14 +1,17 @@
-import { onCleanup as s } from "solid-js";
-import { usePixiApp as i } from "./pixi-application.js";
-const t = (n) => {
-  const e = i(), r = () => {
-    n(e.renderer.screen);
+import { onCleanup } from "solid-js";
+import { usePixiApp } from "./pixi-application.js";
+const useResize = (resizeCallback) => {
+  const app = usePixiApp();
+  const handleResize = () => {
+    resizeCallback(app.renderer.screen);
   };
-  r(), e.renderer.addListener("resize", r), s(() => {
-    e.renderer.removeListener("resize", r);
+  handleResize();
+  app.renderer.addListener("resize", handleResize);
+  onCleanup(() => {
+    app.renderer.removeListener("resize", handleResize);
   });
 };
 export {
-  t as useResize
+  useResize
 };
 //# sourceMappingURL=use-resize.js.map

package/dist/use-resize.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-resize.js","sources":["../src/use-resize.ts"],"sourcesContent":["import type * as Pixi from \"pixi.js\";\nimport { onCleanup } from \"solid-js\";\nimport { usePixiApp } from \"./pixi-application\";\n\n/**\n * A SolidJS hook that runs a callback function whenever the PixiJS renderer is resized.\n *\n * @param resizeCallback A callback function that receives the updated screen dimensions as a `Pixi.Rectangle` object. This function will be called immediately upon hook initialization and then on every subsequent resize event.\n *\n * Because we listen for the renderer's \"resize\" event, this hook will work correctly whether the window is resized or just the DOM element the PixiCanvas is inside changes size.\n */\nexport const useResize = (resizeCallback: (screen: Pixi.Rectangle) => void): void => {\n  const app = usePixiApp();\n\n  const handleResize = () => {\n    resizeCallback(app.renderer.screen);\n  };\n\n  handleResize();\n\n  app.renderer.addListener(\"resize\", handleResize);\n\n  onCleanup(() => {\n    app.renderer.removeListener(\"resize\", handleResize);\n  });\n};\n"],"names":["useResize","resizeCallback","app","usePixiApp","handleResize","onCleanup"],"mappings":";;AAWO,MAAMA,IAAY,CAACC,MAA2D;AACnF,QAAMC,IAAMC,EAAA,GAENC,IAAe,MAAM;AACzB,IAAAH,EAAeC,EAAI,SAAS,MAAM;AAAA,EACpC;AAEA,EAAAE,EAAA,GAEAF,EAAI,SAAS,YAAY,UAAUE,CAAY,GAE/CC,EAAU,MAAM;AACd,IAAAH,EAAI,SAAS,eAAe,UAAUE,CAAY;AAAA,EACpD,CAAC;AACH;"}
+{"version":3,"file":"use-resize.js","sources":["../src/use-resize.ts"],"sourcesContent":["import type * as Pixi from \"pixi.js\";\nimport { onCleanup } from \"solid-js\";\nimport { usePixiApp } from \"./pixi-application\";\n\n/**\n * A SolidJS hook that runs a callback function whenever the PixiJS renderer is resized.\n *\n * @param resizeCallback A callback function that receives the updated screen dimensions as a `Pixi.Rectangle` object. This function will be called immediately upon hook initialization and then on every subsequent resize event.\n *\n * Because we listen for the renderer's \"resize\" event, this hook will work correctly whether the window is resized or just the DOM element the PixiCanvas is inside changes size.\n */\nexport const useResize = (resizeCallback: (screen: Pixi.Rectangle) => void): void => {\n  const app = usePixiApp();\n\n  const handleResize = () => {\n    resizeCallback(app.renderer.screen);\n  };\n\n  handleResize();\n\n  app.renderer.addListener(\"resize\", handleResize);\n\n  onCleanup(() => {\n    app.renderer.removeListener(\"resize\", handleResize);\n  });\n};\n"],"names":[],"mappings":";;AAWO,MAAM,YAAY,CAAC,mBAA2D;AACnF,QAAM,MAAM,WAAA;AAEZ,QAAM,eAAe,MAAM;AACzB,mBAAe,IAAI,SAAS,MAAM;AAAA,EACpC;AAEA,eAAA;AAEA,MAAI,SAAS,YAAY,UAAU,YAAY;AAE/C,YAAU,MAAM;AACd,QAAI,SAAS,eAAe,UAAU,YAAY;AAAA,EACpD,CAAC;AACH;"}

package/dist/utils/index.js

@@ -1,5 +1,5 @@
-import { objectFit as e } from "./object-fit.js";
+import { objectFit } from "./object-fit.js";
 export {
-  e as objectFit
+  objectFit
 };
 //# sourceMappingURL=index.js.map

package/dist/utils/object-fit.js

@@ -1,37 +1,47 @@
-const g = (i, t, r) => {
-  const s = i.width / i.scale.x, n = i.height / i.scale.y;
-  if (s === 0 || n === 0 || t.width === 0 || t.height === 0)
+const objectFit = (object, bounds, fitMode) => {
+  const originalWidth = object.width / object.scale.x;
+  const originalHeight = object.height / object.scale.y;
+  if (originalWidth === 0 || originalHeight === 0 || bounds.width === 0 || bounds.height === 0)
     return;
-  const c = t.width / s, l = t.height / n;
-  let e = 1, h = 1;
-  switch (r) {
+  const widthRatio = bounds.width / originalWidth;
+  const heightRatio = bounds.height / originalHeight;
+  let scaleX = 1;
+  let scaleY = 1;
+  switch (fitMode) {
     case "cover": {
-      const a = Math.max(c, l);
-      e = a, h = a;
+      const coverScale = Math.max(widthRatio, heightRatio);
+      scaleX = coverScale;
+      scaleY = coverScale;
       break;
     }
     case "contain": {
-      const a = Math.min(c, l);
-      e = a, h = a;
+      const containScale = Math.min(widthRatio, heightRatio);
+      scaleX = containScale;
+      scaleY = containScale;
       break;
     }
     case "fill": {
-      e = c, h = l;
+      scaleX = widthRatio;
+      scaleY = heightRatio;
       break;
     }
     case "scale-down": {
-      if (s <= t.width && n <= t.height)
-        e = 1, h = 1;
-      else {
-        const a = Math.min(c, l);
-        e = a, h = a;
+      if (originalWidth <= bounds.width && originalHeight <= bounds.height) {
+        scaleX = 1;
+        scaleY = 1;
+      } else {
+        const scaleDown = Math.min(widthRatio, heightRatio);
+        scaleX = scaleDown;
+        scaleY = scaleDown;
       }
       break;
     }
   }
-  i.scale.set(e, h), i.x = (t.width - i.width) / 2, i.y = (t.height - i.height) / 2;
+  object.scale.set(scaleX, scaleY);
+  object.x = (bounds.width - object.width) / 2;
+  object.y = (bounds.height - object.height) / 2;
 };
 export {
-  g as objectFit
+  objectFit
 };
 //# sourceMappingURL=object-fit.js.map

package/dist/utils/object-fit.js.map

@@ -1 +1 @@
-{"version":3,"file":"object-fit.js","sources":["../../src/utils/object-fit.ts"],"sourcesContent":["import type * as Pixi from \"pixi.js\";\n\nexport type ObjectFitMode = \"cover\" | \"contain\" | \"fill\" | \"scale-down\";\n\n/**\n * Scale an object to fit within the given bounds according to the specified fit mode.\n * @param object The object to be scaled.\n * @param bounds The bounds it should fit within.\n * @param fitMode The object fit mode to apply.\n */\nexport const objectFit = (\n  object: Pixi.Container,\n  bounds: { width: number; height: number },\n  fitMode: ObjectFitMode,\n): void => {\n  const originalWidth = object.width / object.scale.x;\n  const originalHeight = object.height / object.scale.y;\n\n  if (originalWidth === 0 || originalHeight === 0 || bounds.width === 0 || bounds.height === 0)\n    return;\n\n  const widthRatio = bounds.width / originalWidth;\n  const heightRatio = bounds.height / originalHeight;\n\n  let scaleX = 1;\n  let scaleY = 1;\n\n  switch (fitMode) {\n    case \"cover\": {\n      const coverScale = Math.max(widthRatio, heightRatio);\n      scaleX = coverScale;\n      scaleY = coverScale;\n      break;\n    }\n    case \"contain\": {\n      const containScale = Math.min(widthRatio, heightRatio);\n      scaleX = containScale;\n      scaleY = containScale;\n      break;\n    }\n    case \"fill\": {\n      scaleX = widthRatio;\n      scaleY = heightRatio;\n      break;\n    }\n    case \"scale-down\": {\n      // If the object is smaller than the container, it's 'none' (no scaling up).\n      // Otherwise, it's 'contain'.\n      if (originalWidth <= bounds.width && originalHeight <= bounds.height) {\n        scaleX = 1;\n        scaleY = 1;\n      } else {\n        const scaleDown = Math.min(widthRatio, heightRatio);\n        scaleX = scaleDown;\n        scaleY = scaleDown;\n      }\n      break;\n    }\n    default:\n      // Default to no scaling if an unknown fitMode is provided\n      break;\n  }\n\n  object.scale.set(scaleX, scaleY);\n\n  // Center the object\n  object.x = (bounds.width - object.width) / 2;\n  object.y = (bounds.height - object.height) / 2;\n};\n"],"names":["objectFit","object","bounds","fitMode","originalWidth","originalHeight","widthRatio","heightRatio","scaleX","scaleY","coverScale","containScale","scaleDown"],"mappings":"AAUO,MAAMA,IAAY,CACvBC,GACAC,GACAC,MACS;AACT,QAAMC,IAAgBH,EAAO,QAAQA,EAAO,MAAM,GAC5CI,IAAiBJ,EAAO,SAASA,EAAO,MAAM;AAEpD,MAAIG,MAAkB,KAAKC,MAAmB,KAAKH,EAAO,UAAU,KAAKA,EAAO,WAAW;AACzF;AAEF,QAAMI,IAAaJ,EAAO,QAAQE,GAC5BG,IAAcL,EAAO,SAASG;AAEpC,MAAIG,IAAS,GACTC,IAAS;AAEb,UAAQN,GAAA;AAAA,IACN,KAAK,SAAS;AACZ,YAAMO,IAAa,KAAK,IAAIJ,GAAYC,CAAW;AACnD,MAAAC,IAASE,GACTD,IAASC;AACT;AAAA,IACF;AAAA,IACA,KAAK,WAAW;AACd,YAAMC,IAAe,KAAK,IAAIL,GAAYC,CAAW;AACrD,MAAAC,IAASG,GACTF,IAASE;AACT;AAAA,IACF;AAAA,IACA,KAAK,QAAQ;AACX,MAAAH,IAASF,GACTG,IAASF;AACT;AAAA,IACF;AAAA,IACA,KAAK,cAAc;AAGjB,UAAIH,KAAiBF,EAAO,SAASG,KAAkBH,EAAO;AAC5D,QAAAM,IAAS,GACTC,IAAS;AAAA,WACJ;AACL,cAAMG,IAAY,KAAK,IAAIN,GAAYC,CAAW;AAClD,QAAAC,IAASI,GACTH,IAASG;AAAA,MACX;AACA;AAAA,IACF;AAAA,EAGE;AAGJ,EAAAX,EAAO,MAAM,IAAIO,GAAQC,CAAM,GAG/BR,EAAO,KAAKC,EAAO,QAAQD,EAAO,SAAS,GAC3CA,EAAO,KAAKC,EAAO,SAASD,EAAO,UAAU;AAC/C;"}
+{"version":3,"file":"object-fit.js","sources":["../../src/utils/object-fit.ts"],"sourcesContent":["import type * as Pixi from \"pixi.js\";\n\nexport type ObjectFitMode = \"cover\" | \"contain\" | \"fill\" | \"scale-down\";\n\n/**\n * Scale an object to fit within the given bounds according to the specified fit mode.\n * @param object The object to be scaled.\n * @param bounds The bounds it should fit within.\n * @param fitMode The object fit mode to apply.\n */\nexport const objectFit = (\n  object: Pixi.Container,\n  bounds: { width: number; height: number },\n  fitMode: ObjectFitMode,\n): void => {\n  const originalWidth = object.width / object.scale.x;\n  const originalHeight = object.height / object.scale.y;\n\n  if (originalWidth === 0 || originalHeight === 0 || bounds.width === 0 || bounds.height === 0)\n    return;\n\n  const widthRatio = bounds.width / originalWidth;\n  const heightRatio = bounds.height / originalHeight;\n\n  let scaleX = 1;\n  let scaleY = 1;\n\n  switch (fitMode) {\n    case \"cover\": {\n      const coverScale = Math.max(widthRatio, heightRatio);\n      scaleX = coverScale;\n      scaleY = coverScale;\n      break;\n    }\n    case \"contain\": {\n      const containScale = Math.min(widthRatio, heightRatio);\n      scaleX = containScale;\n      scaleY = containScale;\n      break;\n    }\n    case \"fill\": {\n      scaleX = widthRatio;\n      scaleY = heightRatio;\n      break;\n    }\n    case \"scale-down\": {\n      // If the object is smaller than the container, it's 'none' (no scaling up).\n      // Otherwise, it's 'contain'.\n      if (originalWidth <= bounds.width && originalHeight <= bounds.height) {\n        scaleX = 1;\n        scaleY = 1;\n      } else {\n        const scaleDown = Math.min(widthRatio, heightRatio);\n        scaleX = scaleDown;\n        scaleY = scaleDown;\n      }\n      break;\n    }\n    default:\n      // Default to no scaling if an unknown fitMode is provided\n      break;\n  }\n\n  object.scale.set(scaleX, scaleY);\n\n  // Center the object\n  object.x = (bounds.width - object.width) / 2;\n  object.y = (bounds.height - object.height) / 2;\n};\n"],"names":[],"mappings":"AAUO,MAAM,YAAY,CACvB,QACA,QACA,YACS;AACT,QAAM,gBAAgB,OAAO,QAAQ,OAAO,MAAM;AAClD,QAAM,iBAAiB,OAAO,SAAS,OAAO,MAAM;AAEpD,MAAI,kBAAkB,KAAK,mBAAmB,KAAK,OAAO,UAAU,KAAK,OAAO,WAAW;AACzF;AAEF,QAAM,aAAa,OAAO,QAAQ;AAClC,QAAM,cAAc,OAAO,SAAS;AAEpC,MAAI,SAAS;AACb,MAAI,SAAS;AAEb,UAAQ,SAAA;AAAA,IACN,KAAK,SAAS;AACZ,YAAM,aAAa,KAAK,IAAI,YAAY,WAAW;AACnD,eAAS;AACT,eAAS;AACT;AAAA,IACF;AAAA,IACA,KAAK,WAAW;AACd,YAAM,eAAe,KAAK,IAAI,YAAY,WAAW;AACrD,eAAS;AACT,eAAS;AACT;AAAA,IACF;AAAA,IACA,KAAK,QAAQ;AACX,eAAS;AACT,eAAS;AACT;AAAA,IACF;AAAA,IACA,KAAK,cAAc;AAGjB,UAAI,iBAAiB,OAAO,SAAS,kBAAkB,OAAO,QAAQ;AACpE,iBAAS;AACT,iBAAS;AAAA,MACX,OAAO;AACL,cAAM,YAAY,KAAK,IAAI,YAAY,WAAW;AAClD,iBAAS;AACT,iBAAS;AAAA,MACX;AACA;AAAA,IACF;AAAA,EAGE;AAGJ,SAAO,MAAM,IAAI,QAAQ,MAAM;AAG/B,SAAO,KAAK,OAAO,QAAQ,OAAO,SAAS;AAC3C,SAAO,KAAK,OAAO,SAAS,OAAO,UAAU;AAC/C;"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pixi-solid",
   "private": false,
-  "version": "0.0.12",
+  "version": "0.0.14",
   "description": "A library to write PixiJS applications with SolidJS",
   "author": "Luke Thompson",
   "license": "MIT",

package/dist/types/use-ticker.d.ts

@@ -1,28 +0,0 @@
-import type { Ticker, TickerCallback } from "pixi.js";
-/**
- * useTicker
- *
- * A custom SolidJS hook that provides access to the PIXI.Application's shared Ticker instance.
- * This hook must be called from a component that is a descendant of `PixiApplication`.
- *
- * @returns The PIXI.Ticker instance from the application context.
- * @throws Will throw an error if used outside of a `PixiApplication` context provider.
- *
- * **Example**
- * {@includeCode ./examples/useTicker.example.tsx}
- */
-export declare const useTicker: () => Ticker;
-/**
- * useTick
- *
- * A custom SolidJS hook that registers a callback function to be executed on every frame
- * of the PIXI.Application's ticker. The callback is automatically removed when the
- * component or hook's owning computation is cleaned up.
- *
- * This hook must be called from a component that is a descendant of `PixiApplication`.
- *
- * @param tickerCallback - The function to call on each ticker update. It receives
- *   the `PIXI.Ticker` instance as its argument.
- *
- */
-export declare const useTick: (tickerCallback: TickerCallback<Ticker>) => void;

package/dist/use-ticker.js

@@ -1,15 +0,0 @@
-import { onCleanup as i } from "solid-js";
-import { usePixiApp as r } from "./pixi-application.js";
-const s = () => r().ticker, c = (o) => {
-  const {
-    ticker: e
-  } = r();
-  e.add(o), i(() => {
-    e.remove(o);
-  });
-};
-export {
-  c as useTick,
-  s as useTicker
-};
-//# sourceMappingURL=use-ticker.js.map

package/dist/use-ticker.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"use-ticker.js","sources":["../src/use-ticker.tsx"],"sourcesContent":["import type { Ticker, TickerCallback } from \"pixi.js\";\n\nimport { onCleanup } from \"solid-js\";\nimport { usePixiApp } from \"./pixi-application\";\n\n/**\n * useTicker\n *\n * A custom SolidJS hook that provides access to the PIXI.Application's shared Ticker instance.\n * This hook must be called from a component that is a descendant of `PixiApplication`.\n *\n * @returns The PIXI.Ticker instance from the application context.\n * @throws Will throw an error if used outside of a `PixiApplication` context provider.\n *\n * **Example**\n * {@includeCode ./examples/useTicker.example.tsx}\n */\nexport const useTicker = (): Ticker => usePixiApp().ticker;\n\n/**\n * useTick\n *\n * A custom SolidJS hook that registers a callback function to be executed on every frame\n * of the PIXI.Application's ticker. The callback is automatically removed when the\n * component or hook's owning computation is cleaned up.\n *\n * This hook must be called from a component that is a descendant of `PixiApplication`.\n *\n * @param tickerCallback - The function to call on each ticker update. It receives\n *   the `PIXI.Ticker` instance as its argument.\n *\n */\nexport const useTick = (tickerCallback: TickerCallback<Ticker>): void => {\n  const { ticker } = usePixiApp();\n\n  ticker.add(tickerCallback);\n  onCleanup(() => {\n    ticker.remove(tickerCallback);\n  });\n};\n"],"names":["useTicker","usePixiApp","ticker","useTick","tickerCallback","add","onCleanup","remove"],"mappings":";;AAiBO,MAAMA,IAAYA,MAAcC,IAAaC,QAevCC,IAAUA,CAACC,MAAiD;AACvE,QAAM;AAAA,IAAEF,QAAAA;AAAAA,EAAAA,IAAWD,EAAAA;AAEnBC,EAAAA,EAAOG,IAAID,CAAc,GACzBE,EAAU,MAAM;AACdJ,IAAAA,EAAOK,OAAOH,CAAc;AAAA,EAC9B,CAAC;AACH;"}