@number10/phaserjsx 0.1.0

package/dist/portal/portal-registry.d.ts

@@ -0,0 +1,97 @@
+import { default as Phaser } from 'phaser';
+import { VNode } from '../hooks';
+import { PortalTree } from './portal-types';
+/**
+ * Global portal registry
+ * Manages all portal trees across scenes with depth-based ordering
+ */
+declare class PortalRegistry {
+    private portals;
+    private idCounter;
+    private portalRoots;
+    private viewportSizes;
+    /**
+     * Generate unique portal ID
+     * @returns Unique portal ID
+     */
+    generateId(): string;
+    /**
+     * Get or create portal root container for scene
+     * This container sits at very high depth to ensure portals are above regular content
+     * @param scene - Phaser scene
+     * @returns Portal root container
+     */
+    private getOrCreatePortalRoot;
+    /**
+     * Register a new portal tree
+     * @param id - Portal ID
+     * @param depth - Z-depth (higher = foreground)
+     * @param scene - Phaser scene
+     * @param vnode - Root VNode
+     * @param mountedNode - Mounted GameObject
+     * @returns Portal container
+     */
+    register(id: string, depth: number, scene: Phaser.Scene, vnode: VNode, mountedNode: Phaser.GameObjects.GameObject): Phaser.GameObjects.Container;
+    /**
+     * Sort portals in scene by depth (highest to lowest)
+     * Ensures correct input event order within portal root
+     * Phaser processes input from LAST to FIRST child in DisplayList
+     * So highest depth should be LAST in the list to receive events first
+     * @param scene - Phaser scene
+     */
+    private sortPortalsByDepth;
+    /**
+     * Unregister and cleanup portal
+     * @param id - Portal ID
+     */
+    unregister(id: string): void;
+    /**
+     * Get portal by ID
+     * @param id - Portal ID
+     * @returns Portal tree or undefined
+     */
+    get(id: string): PortalTree | undefined;
+    /**
+     * Get all portals sorted by depth (ascending)
+     * @returns Sorted portal trees
+     */
+    getByDepth(): PortalTree[];
+    /**
+     * Get all portals for a specific scene
+     * @param scene - Phaser scene
+     * @returns Portal trees in scene
+     */
+    getByScene(scene: Phaser.Scene): PortalTree[];
+    /**
+     * Clear all portals
+     */
+    clear(): void;
+    /**
+     * Set viewport size for a scene
+     * Used by Portal system to know screen dimensions for centering
+     * @param scene - Phaser scene
+     * @param width - Viewport width
+     * @param height - Viewport height
+     */
+    setViewportSize(scene: Phaser.Scene, width: number, height: number): void;
+    /**
+     * Get viewport size for a scene
+     * @param scene - Phaser scene
+     * @returns Viewport size or default 800x600
+     */
+    getViewportSize(scene: Phaser.Scene): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Get portal count
+     * @returns Number of registered portals
+     */
+    get size(): number;
+}
+/**
+ * Global portal registry instance
+ */
+export declare const portalRegistry: PortalRegistry;
+export {};
+//# sourceMappingURL=portal-registry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"portal-registry.d.ts","sourceRoot":"","sources":["../../src/portal/portal-registry.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAA;AAChC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AACrC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAEhD;;;GAGG;AACH,cAAM,cAAc;IAClB,OAAO,CAAC,OAAO,CAAqC;IACpD,OAAO,CAAC,SAAS,CAAI;IACrB,OAAO,CAAC,WAAW,CAA6D;IAChF,OAAO,CAAC,aAAa,CAAkE;IAEvF;;;OAGG;IACH,UAAU,IAAI,MAAM;IAIpB;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IAe7B;;;;;;;;OAQG;IACH,QAAQ,CACN,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,CAAC,KAAK,EACnB,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,MAAM,CAAC,WAAW,CAAC,UAAU,GACzC,MAAM,CAAC,WAAW,CAAC,SAAS;IA2B/B;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;IAoB1B;;;OAGG;IACH,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAoB5B;;;;OAIG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS;IAIvC;;;OAGG;IACH,UAAU,IAAI,UAAU,EAAE;IAI1B;;;;OAIG;IACH,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,GAAG,UAAU,EAAE;IAI7C;;OAEG;IACH,KAAK,IAAI,IAAI;IAOb;;;;;;OAMG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAIzE;;;;OAIG;IACH,eAAe,CAAC,KAAK,EAAE,MAAM,CAAC,KAAK,GAAG;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;IAIvE;;;OAGG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF;AAED;;GAEG;AACH,eAAO,MAAM,cAAc,gBAAuB,CAAA"}

package/dist/portal/portal-types.d.ts

@@ -0,0 +1,20 @@
+import { default as Phaser } from 'phaser';
+import { VNode } from '../hooks';
+/**
+ * Portal tree instance
+ */
+export interface PortalTree {
+    /** Unique portal ID */
+    id: string;
+    /** Depth/z-index for stacking order (higher = foreground) */
+    depth: number;
+    /** Root Phaser container for this portal */
+    container: Phaser.GameObjects.Container;
+    /** Root VNode being rendered */
+    vnode: VNode;
+    /** Scene this portal belongs to */
+    scene: Phaser.Scene;
+    /** Mounted GameObject */
+    mountedNode: Phaser.GameObjects.GameObject;
+}
+//# sourceMappingURL=portal-types.d.ts.map

package/dist/portal/portal-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"portal-types.d.ts","sourceRoot":"","sources":["../../src/portal/portal-types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,MAAM,MAAM,QAAQ,CAAA;AAChC,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,UAAU,CAAA;AAErC;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,uBAAuB;IACvB,EAAE,EAAE,MAAM,CAAA;IACV,6DAA6D;IAC7D,KAAK,EAAE,MAAM,CAAA;IACb,4CAA4C;IAC5C,SAAS,EAAE,MAAM,CAAC,WAAW,CAAC,SAAS,CAAA;IACvC,gCAAgC;IAChC,KAAK,EAAE,KAAK,CAAA;IACZ,mCAAmC;IACnC,KAAK,EAAE,MAAM,CAAC,KAAK,CAAA;IACnB,yBAAyB;IACzB,WAAW,EAAE,MAAM,CAAC,WAAW,CAAC,UAAU,CAAA;CAC3C"}

package/dist/render-context.d.ts

@@ -0,0 +1,118 @@
+import { default as Phaser } from 'phaser';
+import { Ctx } from './hooks';
+import { ParentType } from './types';
+/**
+ * Layout batch entry for deferred recalculation
+ */
+interface LayoutBatchEntry {
+    container: Phaser.GameObjects.Container;
+    containerProps: unknown;
+    parentSize: {
+        width: number;
+        height: number;
+    } | undefined;
+    parentPadding: {
+        horizontal: number;
+        vertical: number;
+    } | undefined;
+}
+/**
+ * Render context - encapsulates all previously global state
+ * Each mount point gets its own isolated context
+ */
+export declare class RenderContext {
+    scene: Phaser.Scene;
+    private currentCtx;
+    private textureScene;
+    private textures;
+    private viewport;
+    private viewportParent;
+    private deferredCallbacks;
+    private deferredScheduled;
+    private layoutBatchMap;
+    private batchScheduled;
+    private isShuttingDown;
+    constructor(scene: Phaser.Scene);
+    /**
+     * Check if context is shutting down
+     */
+    isShutdown(): boolean;
+    /**
+     * Mark context as shutting down
+     */
+    shutdown(): void;
+    /**
+     * Get current hook context
+     */
+    getCurrent(): Ctx | null;
+    /**
+     * Set current hook context
+     */
+    setCurrent(ctx: Ctx | null): void;
+    /**
+     * Get texture scene
+     */
+    getTextureScene(): Phaser.Scene | null;
+    /**
+     * Get textures map
+     */
+    getTextures(): Map<string, {
+        refCount: number;
+        promise: Promise<void> | null;
+        loaded: boolean;
+    }>;
+    /**
+     * Set viewport dimensions
+     */
+    setViewport(width: number, height: number, parent?: ParentType): void;
+    /**
+     * Get viewport dimensions
+     */
+    getViewport(): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Get viewport parent
+     */
+    getViewportParent(): ParentType | undefined;
+    /**
+     * Defer a layout callback to next frame
+     */
+    deferLayout(callback: () => void): void;
+    /**
+     * Flush all deferred layout callbacks
+     */
+    private flushDeferred;
+    /**
+     * Get layout batch map
+     */
+    getLayoutBatch(): Map<Phaser.GameObjects.Container, LayoutBatchEntry>;
+    /**
+     * Clear layout batch
+     */
+    clearLayoutBatch(): void;
+    /**
+     * Check if batch is scheduled
+     */
+    isBatchScheduled(): boolean;
+    /**
+     * Set batch scheduled flag
+     */
+    setBatchScheduled(scheduled: boolean): void;
+}
+/**
+ * Get or create RenderContext for a scene or container
+ * Uses scene.data to store contexts, ensuring proper isolation
+ * @param parentOrScene - Scene or Container to get context for
+ * @returns RenderContext instance
+ */
+export declare function getRenderContext(parentOrScene: Phaser.Scene | Phaser.GameObjects.Container): RenderContext;
+/**
+ * Get RenderContext from a parent (used internally by hooks)
+ * @param parent - Parent scene or container
+ * @returns RenderContext instance
+ */
+export declare function getContextFromParent(parent: ParentType): RenderContext;
+export {};
+//# sourceMappingURL=render-context.d.ts.map

package/dist/render-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render-context.d.ts","sourceRoot":"","sources":["../src/render-context.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,MAAM,MAAM,QAAQ,CAAA;AAE3B,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,SAAS,CAAA;AAClC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEzC;;GAEG;AACH,UAAU,gBAAgB;IACxB,SAAS,EAAE,MAAM,CAAC,WAAW,CAAC,SAAS,CAAA;IACvC,cAAc,EAAE,OAAO,CAAA;IACvB,UAAU,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAA;IACzD,aAAa,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,GAAG,SAAS,CAAA;CACpE;AAED;;;GAGG;AACH,qBAAa,aAAa;IA0BL,KAAK,EAAE,MAAM,CAAC,KAAK;IAxBtC,OAAO,CAAC,UAAU,CAAmB;IAGrC,OAAO,CAAC,YAAY,CAA4B;IAChD,OAAO,CAAC,QAAQ,CAGb;IAGH,OAAO,CAAC,QAAQ,CAAiE;IACjF,OAAO,CAAC,cAAc,CAAwB;IAG9C,OAAO,CAAC,iBAAiB,CAAqB;IAC9C,OAAO,CAAC,iBAAiB,CAAQ;IAGjC,OAAO,CAAC,cAAc,CAA4D;IAClF,OAAO,CAAC,cAAc,CAAQ;IAG9B,OAAO,CAAC,cAAc,CAAQ;gBAEX,KAAK,EAAE,MAAM,CAAC,KAAK;IAItC;;OAEG;IACH,UAAU,IAAI,OAAO;IAIrB;;OAEG;IACH,QAAQ,IAAI,IAAI;IAMhB;;OAEG;IACH,UAAU,IAAI,GAAG,GAAG,IAAI;IAIxB;;OAEG;IACH,UAAU,CAAC,GAAG,EAAE,GAAG,GAAG,IAAI,GAAG,IAAI;IAIjC;;OAEG;IACH,eAAe,IAAI,MAAM,CAAC,KAAK,GAAG,IAAI;IAItC;;OAEG;IACH,WAAW,IAAI,GAAG,CAAC,MAAM,EAAE;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAE,CAAC;IAIhG;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,UAAU,GAAG,IAAI;IAKrE;;OAEG;IACH,WAAW,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE;IAIhD;;OAEG;IACH,iBAAiB,IAAI,UAAU,GAAG,SAAS;IAI3C;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,IAAI;IASvC;;OAEG;IACH,OAAO,CAAC,aAAa;IAcrB;;OAEG;IACH,cAAc,IAAI,GAAG,CAAC,MAAM,CAAC,WAAW,CAAC,SAAS,EAAE,gBAAgB,CAAC;IAIrE;;OAEG;IACH,gBAAgB,IAAI,IAAI;IAIxB;;OAEG;IACH,gBAAgB,IAAI,OAAO;IAI3B;;OAEG;IACH,iBAAiB,CAAC,SAAS,EAAE,OAAO,GAAG,IAAI;CAG5C;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,aAAa,EAAE,MAAM,CAAC,KAAK,GAAG,MAAM,CAAC,WAAW,CAAC,SAAS,GACzD,aAAa,CA8Bf;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,UAAU,GAAG,aAAa,CAKtE"}

package/dist/scripts/generate-icon-loaders.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generate-icon-loaders.d.ts.map

package/dist/scripts/generate-icon-loaders.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-icon-loaders.d.ts","sourceRoot":"","sources":["../../src/scripts/generate-icon-loaders.ts"],"names":[],"mappings":""}

package/dist/scripts/generate-icon-loaders.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+import { readFile, writeFile, readdir } from "node:fs/promises";
+import { resolve, join } from "node:path";
+import { parseArgs } from "node:util";
+async function findTsFiles(dir) {
+  const files = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules" || entry.name === "dist") continue;
+      files.push(...await findTsFiles(fullPath));
+    } else if (entry.isFile() && /\.(tsx?|jsx?)$/.test(entry.name)) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function extractIconNames(content, componentNames) {
+  const iconNames = /* @__PURE__ */ new Set();
+  let match;
+  for (const componentName of componentNames) {
+    const typePattern = new RegExp(
+      `<${componentName}\\s+[^>]*type=(?:["']([^"']+)["']|\\{['"]([^"']+)["']}})`,
+      "g"
+    );
+    while ((match = typePattern.exec(content)) !== null) {
+      const iconName = match[1] || match[2];
+      if (iconName) {
+        iconNames.add(iconName);
+      }
+    }
+  }
+  const themedPattern = /themed\.(\w*[Ii]con)\s*\?\?\s*["']([^"']+)["']/g;
+  while ((match = themedPattern.exec(content)) !== null) {
+    if (match[2]) {
+      iconNames.add(match[2]);
+    }
+  }
+  const iconPropPattern = /(?:icon|iconType):\s*["']([^"']+)["']/g;
+  while ((match = iconPropPattern.exec(content)) !== null) {
+    if (match[1]) {
+      iconNames.add(match[1]);
+    }
+  }
+  return iconNames;
+}
+async function loadAvailableIcons(typesFile) {
+  try {
+    const content = await readFile(typesFile, "utf-8");
+    const match = content.match(/(?:export\s+)?type\s+\w+\s*=\s*([\s\S]+?)(?=\n\nexport|\n\/\/|$)/s);
+    if (!match?.[1]) return null;
+    const typeContent = match[1];
+    const icons = /* @__PURE__ */ new Set();
+    const iconPattern = /'([^']+)'/g;
+    let iconMatch;
+    while ((iconMatch = iconPattern.exec(typeContent)) !== null) {
+      const iconName = iconMatch[1];
+      if (iconName) {
+        icons.add(iconName);
+      }
+    }
+    return icons;
+  } catch {
+    return null;
+  }
+}
+async function generateIconLoaders(options2) {
+  try {
+    const cwd = process.cwd();
+    const srcDir = resolve(cwd, options2.source);
+    const componentNames = options2.componentNames || [options2.componentName || "Icon"];
+    console.log(`📁 Scanning directory: ${srcDir}`);
+    console.log(`🔍 Looking for components: ${componentNames.join(", ")}`);
+    let availableIcons = null;
+    if (options2.typesFile) {
+      const typesPath = resolve(cwd, options2.typesFile);
+      availableIcons = await loadAvailableIcons(typesPath);
+      if (availableIcons) {
+        console.log(`✓ Loaded ${availableIcons.size} available icons from ${options2.typesFile}`);
+      } else {
+        console.warn(`⚠️  Could not parse types file: ${options2.typesFile}`);
+      }
+    }
+    const files = await findTsFiles(srcDir);
+    console.log(`📄 Found ${files.length} TypeScript files`);
+    const allIconNames = /* @__PURE__ */ new Set();
+    for (const file of files) {
+      const content = await readFile(file, "utf-8");
+      const icons = extractIconNames(content, componentNames);
+      icons.forEach((icon) => allIconNames.add(icon));
+    }
+    let iconArray = Array.from(allIconNames).sort();
+    if (availableIcons) {
+      const invalidIcons = iconArray.filter((icon) => !availableIcons.has(icon));
+      if (invalidIcons.length > 0) {
+        console.warn(`⚠️  Found ${invalidIcons.length} icons not in types file:`);
+        console.warn(
+          `   ${invalidIcons.slice(0, 5).join(", ")}${invalidIcons.length > 5 ? "..." : ""}`
+        );
+      }
+      iconArray = iconArray.filter((icon) => availableIcons.has(icon));
+    }
+    console.log(`✓ Found ${iconArray.length} unique icons`);
+    if (iconArray.length > 0) {
+      console.log(
+        `  Icons: ${iconArray.slice(0, 10).join(", ")}${iconArray.length > 10 ? "..." : ""}`
+      );
+    }
+    const iconsPath = options2.iconsPath || "icons";
+    const loaders = iconArray.map((icon) => `  '${icon}': () => import('${options2.package}/${iconsPath}/${icon}.svg'),`).join("\n");
+    const output = `/**
+ * Auto-generated icon loader registry
+ * Package: ${options2.package}
+ * Icons found: ${iconArray.length}
+ *
+ * @generated by @number10/phaserjsx/generate-icon-loaders
+ * @cspell: disable
+ */
+
+/**
+ * Icon loaders - only icons used in the codebase are registered
+ * Bundler will create separate chunks for each icon
+ */
+export const iconLoaders: Record<string, () => Promise<{ default: string }>> = {
+${loaders || "  // No icons found"}
+}
+`;
+    const outputPath = resolve(cwd, options2.output);
+    await writeFile(outputPath, output, "utf-8");
+    console.log(`✓ Generated: ${outputPath}`);
+    console.log(`✓ Registered ${iconArray.length} icon loaders`);
+  } catch (error) {
+    console.error("❌ Error generating icon loaders:", error);
+    process.exit(1);
+  }
+}
+const { values } = parseArgs({
+  options: {
+    source: { type: "string", short: "s" },
+    output: { type: "string", short: "o" },
+    package: { type: "string", short: "p" },
+    iconsPath: { type: "string", short: "i" },
+    componentName: { type: "string", short: "c" },
+    componentNames: { type: "string", multiple: true },
+    typesFile: { type: "string", short: "t" },
+    help: { type: "boolean", short: "h" }
+  }
+});
+if (values.help || !values.source || !values.output || !values.package) {
+  console.log(`
+Usage: generate-icon-loaders [options]
+
+Options:
+  -s, --source <path>         Source directory to scan (e.g., ./src)
+  -o, --output <path>         Output file path (e.g., ./src/components/icon-loaders.generated.ts)
+  -p, --package <name>        Icon package name (e.g., bootstrap-icons)
+  -i, --iconsPath <path>      Relative path to icons in package (default: icons)
+  -c, --componentName <name>  Icon component name to search for (default: Icon)
+  --componentNames <names...> Multiple component names (e.g., Icon BootstrapIcon)
+  -t, --typesFile <path>      Types file for validation (e.g., ./src/icon-types.generated.ts)
+  -h, --help                  Show this help message
+
+Examples:
+  # Single component name
+  generate-icon-loaders -s ./src -o ./src/icon-loaders.generated.ts -p bootstrap-icons
+
+  # Multiple component names
+  generate-icon-loaders -s ./src -o ./src/icon-loaders.generated.ts -p bootstrap-icons \\
+    --componentNames Icon BootstrapIcon CustomIcon
+
+  # With validation
+  generate-icon-loaders -s ./src -o ./src/icon-loaders.generated.ts -p bootstrap-icons \\
+    -t ./src/icon-types.generated.ts
+`);
+  process.exit(values.help ? 0 : 1);
+}
+const options = {
+  source: values.source,
+  output: values.output,
+  package: values.package
+};
+if (values.iconsPath) {
+  options.iconsPath = values.iconsPath;
+}
+if (values.componentName) {
+  options.componentName = values.componentName;
+}
+if (values.componentNames && values.componentNames.length > 0) {
+  options.componentNames = values.componentNames;
+}
+if (values.typesFile) {
+  options.typesFile = values.typesFile;
+}
+generateIconLoaders(options);

package/dist/scripts/generate-icon-types.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generate-icon-types.d.ts.map

package/dist/scripts/generate-icon-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-icon-types.d.ts","sourceRoot":"","sources":["../../src/scripts/generate-icon-types.ts"],"names":[],"mappings":""}

package/dist/scripts/generate-icon-types.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+import { readdir, writeFile } from "node:fs/promises";
+import { resolve, join, basename } from "node:path";
+import { parseArgs } from "node:util";
+async function findIconPackage(packageName, cwd) {
+  const fs = await import("node:fs");
+  const pnpmBase = join(cwd, "node_modules/.pnpm");
+  if (fs.existsSync(pnpmBase)) {
+    const entries = await readdir(pnpmBase);
+    for (const entry of entries) {
+      if (entry.startsWith(`${packageName}@`)) {
+        const packagePath = join(pnpmBase, entry, "node_modules", packageName);
+        if (fs.existsSync(packagePath)) {
+          return packagePath;
+        }
+      }
+    }
+  }
+  const standardPath = join(cwd, "node_modules", packageName);
+  if (fs.existsSync(standardPath)) {
+    return standardPath;
+  }
+  throw new Error(`Could not find package: ${packageName}`);
+}
+async function generateIconTypes(options2) {
+  try {
+    const cwd = process.cwd();
+    let iconsDir;
+    let sourceName;
+    if (options2.directory) {
+      iconsDir = resolve(cwd, options2.directory);
+      sourceName = options2.directory;
+      console.log(`📁 Scanning directory: ${options2.directory}`);
+    } else if (options2.package) {
+      const packagePath = await findIconPackage(options2.package, cwd);
+      iconsDir = join(packagePath, options2.iconsPath || "icons");
+      sourceName = options2.package;
+      console.log(`📦 Scanning package: ${options2.package}`);
+    } else {
+      throw new Error("Either --package or --directory must be specified");
+    }
+    console.log(`📁 Icons directory: ${iconsDir}`);
+    const files = await readdir(iconsDir);
+    const iconNames = files.filter((file) => file.endsWith(".svg")).map((file) => basename(file, ".svg")).sort();
+    console.log(`✓ Found ${iconNames.length} icons`);
+    const typeDefinition = iconNames.map((name) => `  | '${name}'`).join("\n");
+    const typeName = options2.typeName || "IconType";
+    const output = `/**
+ * Auto-generated icon type definitions
+ * Source: ${sourceName}
+ * Total icons: ${iconNames.length}
+ *
+ * @generated by @number10/phaserjsx/generate-icon-types
+ * @cspell: disable
+ */
+
+/**
+ * All available icon names from ${sourceName}
+ * Type-only definition - no runtime imports, zero bundle impact
+ */
+export type ${typeName} =
+${typeDefinition}
+`;
+    const outputPath = resolve(cwd, options2.output);
+    await writeFile(outputPath, output, "utf-8");
+    console.log(`✓ Generated: ${outputPath}`);
+    console.log(`✓ Type name: ${typeName}`);
+    console.log(`✓ Total icons: ${iconNames.length}`);
+    if (iconNames.length > 0) {
+      console.log(`  First: ${iconNames[0]}`);
+      console.log(`  Last: ${iconNames[iconNames.length - 1]}`);
+    }
+  } catch (error) {
+    console.error("❌ Error generating icon types:", error);
+    process.exit(1);
+  }
+}
+const { values } = parseArgs({
+  options: {
+    package: { type: "string", short: "p" },
+    directory: { type: "string", short: "d" },
+    output: { type: "string", short: "o" },
+    typeName: { type: "string", short: "t" },
+    iconsPath: { type: "string", short: "i" },
+    help: { type: "boolean", short: "h" }
+  }
+});
+if (values.help || !values.package && !values.directory || !values.output) {
+  console.log(`
+Usage: generate-icon-types [options]
+
+Options:
+  -p, --package <name>      Icon package name (e.g., bootstrap-icons)
+  -d, --directory <path>    Local directory with SVG files (alternative to --package)
+  -o, --output <path>       Output file path (e.g., ./src/types/icons.ts)
+  -t, --typeName <name>     TypeScript type name (default: IconType)
+  -i, --iconsPath <path>    Relative path to icons in package (default: icons)
+  -h, --help                Show this help message
+
+Examples:
+  # From npm package
+  generate-icon-types -p bootstrap-icons -o ./src/icon-types.generated.ts
+
+  # From local directory
+  generate-icon-types -d ./public/icons -o ./src/icon-types.generated.ts
+`);
+  process.exit(values.help ? 0 : 1);
+}
+const options = {
+  output: values.output
+};
+if (values.package) {
+  options.package = values.package;
+}
+if (values.directory) {
+  options.directory = values.directory;
+}
+if (values.typeName) {
+  options.typeName = values.typeName;
+}
+if (values.iconsPath) {
+  options.iconsPath = values.iconsPath;
+}
+generateIconTypes(options);

package/dist/scripts/generate-icons.d.ts

@@ -0,0 +1,37 @@
+import { IconGeneratorConfig } from './icon-generator-config';
+/**
+ * Generate icon types
+ * Exported for use by Vite plugin
+ */
+export declare function generateTypes(config: IconGeneratorConfig, cwd: string): Promise<{
+    iconNames: string[];
+    sourceIconSets: Map<number, Set<string>>;
+} | null>;
+/**
+ * Scan icon sources without generating the types file
+ * Used by Vite plugin to get sourceIconSets for loader generation without full type regeneration
+ * @param config - Icon generator configuration
+ * @param cwd - Current working directory
+ * @returns Icon names and source mapping
+ */
+export declare function scanIconSources(config: IconGeneratorConfig, cwd: string): Promise<{
+    iconNames: string[];
+    sourceIconSets: Map<number, Set<string>>;
+}>;
+/**
+ * Generate icon loaders
+ * Exported for use by Vite plugin
+ */
+export declare function generateLoaders(config: IconGeneratorConfig, cwd: string, typesResult?: {
+    iconNames: string[];
+    sourceIconSets: Map<number, Set<string>>;
+}): Promise<void>;
+/**
+ * Load config file
+ */
+/**
+ * Load icon generator config file
+ * Exported for use by Vite plugin and other tools
+ */
+export declare function loadConfig(configPath: string, cwd?: string): Promise<IconGeneratorConfig>;
+//# sourceMappingURL=generate-icons.d.ts.map

package/dist/scripts/generate-icons.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-icons.d.ts","sourceRoot":"","sources":["../../src/scripts/generate-icons.ts"],"names":[],"mappings":"AAeA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAA;AA8IlE;;;GAGG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,mBAAmB,EAC3B,GAAG,EAAE,MAAM,GACV,OAAO,CAAC;IAAE,SAAS,EAAE,MAAM,EAAE,CAAC;IAAC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;CAAE,GAAG,IAAI,CAAC,CA+EnF;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,mBAAmB,EAC3B,GAAG,EAAE,MAAM,GACV,OAAO,CAAC;IAAE,SAAS,EAAE,MAAM,EAAE,CAAC;IAAC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;CAAE,CAAC,CAgC5E;AAED;;;GAGG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,mBAAmB,EAC3B,GAAG,EAAE,MAAM,EACX,WAAW,CAAC,EAAE;IAAE,SAAS,EAAE,MAAM,EAAE,CAAC;IAAC,cAAc,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;CAAE,GAC9E,OAAO,CAAC,IAAI,CAAC,CAgLf;AAED;;GAEG;AACH;;;GAGG;AACH,wBAAsB,UAAU,CAC9B,UAAU,EAAE,MAAM,EAClB,GAAG,SAAgB,GAClB,OAAO,CAAC,mBAAmB,CAAC,CA6B9B"}