@number10/phaserjsx 0.1.0

package/dist/index.js

@@ -0,0 +1,582 @@
+import { p as useRef, q as useEffect, r as useState, t as themeRegistry, s as useTheme, v as getPresetWithMode, w as alpha, x as defaultRadiusTokens, y as defaultSizeTokens, z as defaultSpacingTokens, E as createTextStyleTokens, F as registerBuiltins } from "./TransformOriginView-CO-tJCmV.js";
+import { A, a, B, C, b, $, b9, K, V, X, Y, D, c, d, a0, aP, be, I, f, L, M, N, g, P, R, h, m, i, ba, S, k, l, n, bb, aO, aR, aQ, T, o, aS, W, b6, br, a1, bs, j, a3, a4, aK, a5, a6, a7, a8, a9, e, aa, ab, ac, ad, ae, af, ag, ah, ai, aj, bo, aI, ak, al, am, an, bj, bk, bz, aG, ax, bp, bt, bu, bq, ao, bv, U, aJ, b1, b2, bl, bf, aF, a$, b0, b7, bm, bn, aH, bw, aL, O, O as O2, aX, aY, aD, G, H, J, bg, bh, bx, aN, b5, by, aE, aA, ay, az, a2, bi, au, av, aZ, a_, Z, aT, aU, b3, b4, aM, b8, as, aq, _, u, ar, aw, aB, aC, at, bc, bd, aV, aW, Q, ap } from "./TransformOriginView-CO-tJCmV.js";
+import { Fragment, jsx, jsxs } from "./jsx-runtime.js";
+import { computed } from "@preact/signals-core";
+function useFX(ref) {
+  const activeEffectsRef = useRef(/* @__PURE__ */ new Set());
+  useEffect(() => {
+    return () => {
+      activeEffectsRef.current.forEach((cleanup) => {
+        if (typeof cleanup === "function") {
+          cleanup();
+        } else if (cleanup?.destroy) {
+          cleanup.destroy();
+        }
+      });
+      activeEffectsRef.current.clear();
+    };
+  }, []);
+  const applyFX = (fxCreator, config, type = "post") => {
+    const obj = ref.current;
+    if (!obj) {
+      console.warn("[useFX] No object found in ref");
+      return;
+    }
+    const cleanupOrController = fxCreator(obj, config, type);
+    if (cleanupOrController) {
+      activeEffectsRef.current.add(cleanupOrController);
+    }
+  };
+  const clearFX = () => {
+    activeEffectsRef.current.forEach((cleanup) => {
+      if (typeof cleanup === "function") {
+        cleanup();
+      } else if (cleanup?.destroy) {
+        cleanup.destroy();
+      }
+    });
+    activeEffectsRef.current.clear();
+    const obj = ref.current;
+    if (obj && "postFX" in obj && obj.postFX) {
+      obj.postFX.clear();
+    }
+    if (obj && "preFX" in obj && obj.preFX) {
+      obj.preFX.clear();
+    }
+  };
+  return { applyFX, clearFX };
+}
+const createBlurFX = (obj, config, type = "post") => {
+  const { quality = 0, x = 2, y = 2, strength = 1, color = 16777215, steps = 4 } = config;
+  const pipeline = type === "post" ? obj.postFX : obj.preFX;
+  if (!pipeline) {
+    console.warn("[createBlurFX] FX pipeline not available on this GameObject");
+    return null;
+  }
+  const blur = pipeline.addBlur(quality, x, y, strength, color, steps);
+  return blur;
+};
+const createColorMatrixFX = (obj, config, type = "post") => {
+  const { effect = "grayscale", amount = 1 } = config;
+  const pipeline = type === "post" ? obj.postFX : obj.preFX;
+  if (!pipeline) {
+    console.warn("[createColorMatrixFX] FX pipeline not available on this GameObject");
+    return null;
+  }
+  const colorMatrix = pipeline.addColorMatrix();
+  switch (effect) {
+    case "grayscale":
+      colorMatrix.grayscale(amount);
+      break;
+    case "sepia":
+      colorMatrix.sepia();
+      break;
+    case "negative":
+      colorMatrix.negative();
+      break;
+    case "blackWhite":
+      colorMatrix.blackWhite();
+      break;
+    case "brown":
+      colorMatrix.brown();
+      break;
+    case "kodachrome":
+      colorMatrix.kodachrome();
+      break;
+    case "technicolor":
+      colorMatrix.technicolor();
+      break;
+    case "polaroid":
+      colorMatrix.polaroid();
+      break;
+  }
+  return colorMatrix;
+};
+const createGlowFX = (obj, config, type = "post") => {
+  const {
+    color = 16777215,
+    outerStrength = 4,
+    innerStrength = 0,
+    knockout = false,
+    quality = 0.1,
+    distance = 10
+  } = config;
+  const pipeline = type === "post" ? obj.postFX : obj.preFX;
+  if (!pipeline) {
+    console.warn("[createGlowFX] FX pipeline not available on this GameObject");
+    return null;
+  }
+  const glow = pipeline.addGlow(color, outerStrength, innerStrength, knockout, quality, distance);
+  return glow;
+};
+const createPixelateFX = (obj, config, type = "post") => {
+  const { amount = 1 } = config;
+  const pipeline = type === "post" ? obj.postFX : obj.preFX;
+  if (!pipeline) {
+    console.warn("[createPixelateFX] FX pipeline not available on this GameObject");
+    return null;
+  }
+  const pixelate = pipeline.addPixelate(amount);
+  return pixelate;
+};
+const createShadowFX = (obj, config, type = "post") => {
+  const {
+    x = 0,
+    y = 1,
+    decay = 0.05,
+    power = 1,
+    color = 0,
+    samples = 6,
+    intensity = 1
+  } = config;
+  const pipeline = type === "post" ? obj.postFX : obj.preFX;
+  if (!pipeline) {
+    console.warn("[createShadowFX] FX pipeline not available on this GameObject");
+    return null;
+  }
+  const shadow = pipeline.addShadow(x, y, decay, power, color, samples, intensity);
+  return shadow;
+};
+const createVignetteFX = (obj, config, type = "post") => {
+  const { strength = 0.5, radius = 0.5, x = 0.5, y = 0.5 } = config;
+  const pipeline = type === "post" ? obj.postFX : obj.preFX;
+  if (!pipeline) {
+    console.warn("[createVignetteFX] FX pipeline not available on this GameObject");
+    return null;
+  }
+  const vignette = pipeline.addVignette(x, y, radius, strength);
+  return vignette;
+};
+const FX_REGISTRY = {
+  shadow: createShadowFX,
+  glow: createGlowFX,
+  blur: createBlurFX,
+  pixelate: createPixelateFX,
+  vignette: createVignetteFX,
+  grayscale: (obj, config, type) => createColorMatrixFX(obj, { ...config, effect: "grayscale" }, type),
+  sepia: (obj, config, type) => createColorMatrixFX(obj, { ...config, effect: "sepia" }, type),
+  negative: (obj, config, type) => createColorMatrixFX(obj, { ...config, effect: "negative" }, type),
+  blackWhite: (obj, config, type) => createColorMatrixFX(obj, { ...config, effect: "blackWhite" }, type),
+  brown: (obj, config, type) => createColorMatrixFX(obj, { ...config, effect: "brown" }, type),
+  kodachrome: (obj, config, type) => createColorMatrixFX(obj, { ...config, effect: "kodachrome" }, type),
+  technicolor: (obj, config, type) => createColorMatrixFX(obj, { ...config, effect: "technicolor" }, type),
+  polaroid: (obj, config, type) => createColorMatrixFX(obj, { ...config, effect: "polaroid" }, type)
+};
+const DEFAULT_FX = "grayscale";
+function resolveFX(fxOrName) {
+  if (typeof fxOrName === "function") {
+    return fxOrName;
+  }
+  return FX_REGISTRY[fxOrName] ?? null;
+}
+function applyFXByName(applyFXFn, fxName, config = {}) {
+  const creator = resolveFX(fxName);
+  if (creator) {
+    applyFXFn(creator, config);
+  } else {
+    console.warn(`[applyFXByName] FX "${fxName}" not found in registry`);
+  }
+}
+function useBlur(ref, config = {}) {
+  const { applyFX, clearFX } = useFX(ref);
+  useEffect(() => {
+    if (!ref.current) return;
+    clearFX();
+    applyFX(createBlurFX, config);
+    return () => clearFX();
+  }, [ref, config, applyFX, clearFX]);
+  return { clearFX };
+}
+function useGlow(ref, config = {}) {
+  const { applyFX, clearFX } = useFX(ref);
+  useEffect(() => {
+    if (!ref.current) return;
+    clearFX();
+    applyFX(createGlowFX, config);
+    return () => clearFX();
+  }, [ref, config, applyFX, clearFX]);
+  return { clearFX };
+}
+function useShadow(ref, config = {}) {
+  const { applyFX, clearFX } = useFX(ref);
+  useEffect(() => {
+    if (!ref.current) return;
+    clearFX();
+    applyFX(createShadowFX, config);
+    return () => clearFX();
+  }, [ref, config, applyFX, clearFX]);
+  return { clearFX };
+}
+function setMemoSafe(vnode, value) {
+  if (Object.isExtensible(vnode)) {
+    vnode.__memo = value;
+    return vnode;
+  }
+  return { ...vnode, __memo: value };
+}
+function noMemo(vnode) {
+  return setMemoSafe(vnode, false);
+}
+function memo(vnode) {
+  return setMemoSafe(vnode, true);
+}
+function useColorMode() {
+  const [colorMode, setColorModeState] = useState(themeRegistry.getColorMode());
+  useEffect(() => {
+    const unsubscribe = themeRegistry.subscribe(() => {
+      setColorModeState(themeRegistry.getColorMode());
+    });
+    return unsubscribe;
+  }, []);
+  const setColorMode = (mode) => {
+    themeRegistry.setColorMode(mode);
+  };
+  const toggleColorMode = () => {
+    const newMode = colorMode === "light" ? "dark" : "light";
+    setColorMode(newMode);
+  };
+  return {
+    colorMode,
+    setColorMode,
+    toggleColorMode
+  };
+}
+function useColors() {
+  const localTheme = useTheme();
+  const getInitialColors = () => {
+    if (localTheme?.__colorPreset) {
+      const preset = getPresetWithMode(
+        localTheme.__colorPreset.name,
+        localTheme.__colorPreset.mode ?? "light"
+      );
+      return preset.colors;
+    }
+    return themeRegistry.getColorTokens();
+  };
+  const [colors, setColors] = useState(getInitialColors());
+  const [, forceUpdate] = useState(0);
+  useEffect(() => {
+    const unsubscribe = themeRegistry.subscribe(() => {
+      if (localTheme?.__colorPreset) {
+        const currentMode = themeRegistry.getColorMode();
+        const preset = getPresetWithMode(
+          localTheme.__colorPreset.name,
+          currentMode
+        );
+        setColors(preset.colors);
+      } else {
+        setColors(themeRegistry.getColorTokens());
+      }
+      forceUpdate((n2) => n2 + 1);
+    });
+    return unsubscribe;
+  }, [localTheme]);
+  return colors;
+}
+function useThemeSubscription() {
+  const [, forceUpdate] = useState(0);
+  useEffect(() => {
+    const unsubscribe = themeRegistry.subscribe(() => {
+      forceUpdate((n2) => n2 + 1);
+    });
+    return unsubscribe;
+  }, []);
+}
+function colorsToTheme(colors, colorKey, options = {}) {
+  const { backgroundShade = "DEFAULT", borderShade = "dark", includeBorder = true } = options;
+  const result = {
+    backgroundColor: colors[colorKey][backgroundShade].toNumber()
+  };
+  if (includeBorder) {
+    result.borderColor = colors[colorKey][borderShade].toNumber();
+  }
+  return result;
+}
+function getTextColor(colors, shade = "DEFAULT", alphaValue) {
+  const color = colors.text[shade];
+  return alphaValue !== void 0 ? alpha(color.toNumber(), alphaValue) : color.toString();
+}
+function getBackgroundColor(colors, shade = "DEFAULT") {
+  return colors.background[shade].toNumber();
+}
+function getSurfaceColor(colors, shade = "DEFAULT") {
+  return colors.surface[shade].toNumber();
+}
+function getBorderColor(colors, shade = "DEFAULT") {
+  return colors.border[shade].toNumber();
+}
+themeRegistry.subscribe(() => {
+  updateColorTokensForMode();
+});
+function setColorPreset(presetName) {
+  const currentMode = themeRegistry.getColorMode();
+  const preset = getPresetWithMode(presetName, currentMode);
+  themeRegistry.setColorTokens(preset.colors);
+  themeRegistry.setCurrentPresetName(presetName);
+}
+function updateColorTokensForMode() {
+  const presetName = themeRegistry.getCurrentPresetName();
+  if (presetName) {
+    const currentMode = themeRegistry.getColorMode();
+    const preset = getPresetWithMode(presetName, currentMode);
+    themeRegistry.setColorTokens(preset.colors);
+  }
+}
+function getCurrentPreset() {
+  return themeRegistry.getCurrentPresetName();
+}
+function getAvailablePresets() {
+  return ["oceanBlue", "forestGreen", "midnight"];
+}
+function useThemeTokens() {
+  const localTheme = useTheme();
+  const getInitialTokens = () => {
+    if (localTheme?.__colorPreset) {
+      const preset = getPresetWithMode(
+        localTheme.__colorPreset.name,
+        localTheme.__colorPreset.mode ?? "light"
+      );
+      return {
+        colors: preset.colors,
+        textStyles: createTextStyleTokens(preset.colors.text.DEFAULT.toString()),
+        spacing: defaultSpacingTokens,
+        sizes: defaultSizeTokens,
+        radius: defaultRadiusTokens
+      };
+    }
+    const colors = themeRegistry.getColorTokens();
+    if (!colors) return void 0;
+    return {
+      colors,
+      textStyles: createTextStyleTokens(colors.text.DEFAULT.toString()),
+      spacing: defaultSpacingTokens,
+      sizes: defaultSizeTokens,
+      radius: defaultRadiusTokens
+    };
+  };
+  const [tokens, setTokens] = useState(getInitialTokens());
+  const [, forceUpdate] = useState(0);
+  useEffect(() => {
+    const unsubscribe = themeRegistry.subscribe(() => {
+      if (localTheme?.__colorPreset) {
+        const currentMode = themeRegistry.getColorMode();
+        const preset = getPresetWithMode(
+          localTheme.__colorPreset.name,
+          currentMode
+        );
+        setTokens({
+          colors: preset.colors,
+          textStyles: createTextStyleTokens(preset.colors.text.DEFAULT.toString()),
+          spacing: defaultSpacingTokens,
+          sizes: defaultSizeTokens,
+          radius: defaultRadiusTokens
+        });
+      } else {
+        const colors = themeRegistry.getColorTokens();
+        if (colors) {
+          setTokens({
+            colors,
+            textStyles: createTextStyleTokens(colors.text.DEFAULT.toString()),
+            spacing: defaultSpacingTokens,
+            sizes: defaultSizeTokens,
+            radius: defaultRadiusTokens
+          });
+        }
+      }
+      forceUpdate((n2) => n2 + 1);
+    });
+    return unsubscribe;
+  }, [localTheme]);
+  return tokens;
+}
+registerBuiltins();
+export {
+  A as Accordion,
+  a as AlertDialog,
+  B as Button,
+  C as CharText,
+  b as CharTextInput,
+  $ as DEFAULT_EFFECT,
+  DEFAULT_FX,
+  b9 as DEFAULT_SPRING_CONFIG,
+  K as DOMInputElement,
+  V as DebugLogger,
+  X as DevConfig,
+  Y as DevPresets,
+  D as Dialog,
+  c as Divider,
+  d as Dropdown,
+  a0 as EFFECT_REGISTRY,
+  FX_REGISTRY,
+  Fragment,
+  aP as Graphics,
+  be as HexColor,
+  I as Icon,
+  f as Image,
+  L as KeyboardInputManager,
+  M as Modal,
+  N as NineSlice,
+  g as NineSliceButton,
+  P as Portal,
+  R as RadioButton,
+  h as RadioGroup,
+  m as RangeSlider,
+  i as RefOriginView,
+  ba as SPRING_PRESETS,
+  S as ScrollSlider,
+  k as ScrollView,
+  l as Sidebar,
+  n as Slider,
+  bb as SpringPhysics,
+  aO as Sprite,
+  aR as Text,
+  aQ as TileSprite,
+  T as Toggle,
+  o as TransformOriginView,
+  aS as View,
+  W as WrapText,
+  alpha,
+  b6 as animatedSignal,
+  br as applyDarkMode,
+  a1 as applyEffectByName,
+  applyFXByName,
+  bs as applyLightMode,
+  j as calculateSliderSize,
+  colorsToTheme,
+  computed,
+  createBlurFX,
+  a3 as createBounceEffect,
+  a4 as createBreatheEffect,
+  createColorMatrixFX,
+  aK as createElement,
+  a5 as createFadeEffect,
+  a6 as createFlashEffect,
+  a7 as createFlipInEffect,
+  a8 as createFlipOutEffect,
+  a9 as createFloatEffect,
+  createGlowFX,
+  e as createIconComponent,
+  aa as createJelloEffect,
+  ab as createNoneEffect,
+  createPixelateFX,
+  ac as createPressEffect,
+  ad as createPulseEffect,
+  createShadowFX,
+  ae as createShakeEffect,
+  af as createSlideInEffect,
+  ag as createSlideOutEffect,
+  ah as createSpinEffect,
+  ai as createSwingEffect,
+  aj as createTadaEffect,
+  bo as createTextStyle,
+  createTextStyleTokens,
+  aI as createTheme,
+  createVignetteFX,
+  ak as createWiggleEffect,
+  al as createWobbleEffect,
+  am as createZoomInEffect,
+  an as createZoomOutEffect,
+  bj as darken,
+  bk as darkenHex,
+  defaultRadiusTokens,
+  defaultSizeTokens,
+  defaultSpacingTokens,
+  bz as defaultTextStyleTokens,
+  aG as defaultTheme,
+  ax as disposeCtx,
+  bp as ensureContrast,
+  bt as forestGreenPreset,
+  bu as generateColorScale,
+  getAvailablePresets,
+  getBackgroundColor,
+  getBorderColor,
+  bq as getContrastRatio,
+  ao as getCurrent,
+  getCurrentPreset,
+  bv as getPreset,
+  getPresetWithMode,
+  U as getRenderContext,
+  getSurfaceColor,
+  getTextColor,
+  aJ as getThemedProps,
+  b1 as graphicsCreator,
+  b2 as graphicsPatcher,
+  bl as hex,
+  bf as hexToNumber,
+  aF as host,
+  a$ as imageCreator,
+  b0 as imagePatcher,
+  b7 as isAnimatedSignal,
+  jsx,
+  jsxs,
+  bm as lighten,
+  bn as lightenHex,
+  memo,
+  aH as mergeThemes,
+  bw as midnightPreset,
+  aL as mount,
+  O as mountComponent,
+  O2 as mountJSX,
+  aX as nineSliceCreator,
+  aY as nineSlicePatcher,
+  noMemo,
+  aD as nodeRegistry,
+  G as normalizeCornerRadius,
+  H as normalizeEdgeInsets,
+  J as normalizeGap,
+  bg as numberToHex,
+  bh as numberToRgb,
+  bx as oceanBluePreset,
+  aN as patchVNode,
+  b5 as portalRegistry,
+  by as presets,
+  aE as register,
+  registerBuiltins,
+  aA as releaseAllSVGTextures,
+  ay as releaseSVGTexture,
+  az as releaseSVGTextures,
+  a2 as resolveEffect,
+  resolveFX,
+  bi as rgbToNumber,
+  setColorPreset,
+  au as shallowEqual,
+  av as shouldComponentUpdate,
+  aZ as spriteCreator,
+  a_ as spritePatcher,
+  Z as svgToTexture,
+  aT as textCreator,
+  aU as textPatcher,
+  themeRegistry,
+  b3 as tileSpriteCreator,
+  b4 as tileSpritePatcher,
+  aM as unmount,
+  b8 as unwrapSignal,
+  useBlur,
+  as as useCallback,
+  useColorMode,
+  useColors,
+  useEffect,
+  useFX,
+  aq as useForceRedraw,
+  _ as useGameObjectEffect,
+  useGlow,
+  u as useIconPreload,
+  ar as useMemo,
+  aw as useRedraw,
+  useRef,
+  aB as useSVGTexture,
+  aC as useSVGTextures,
+  at as useScene,
+  useShadow,
+  bc as useSpring,
+  bd as useSprings,
+  useState,
+  useTheme,
+  useThemeSubscription,
+  useThemeTokens,
+  aV as viewCreator,
+  aW as viewPatcher,
+  Q as viewportRegistry,
+  ap as withHooks
+};
+//# sourceMappingURL=index.js.map