@number10/phaserjsx 0.1.0

package/dist/scripts/generate-icons.js

@@ -0,0 +1,494 @@
+#!/usr/bin/env node
+import { watch } from "node:fs";
+import { readdir, writeFile, readFile, access } from "node:fs/promises";
+import { resolve, extname, join, basename, dirname, relative } from "node:path";
+import { pathToFileURL } from "node:url";
+import { parseArgs } from "node:util";
+const TS_CONFIG_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".mts", ".cts", ".tsx"]);
+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 findTsFiles(dir, exclude = []) {
+  const files = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join(dir, entry.name);
+    if (exclude.some((pattern) => fullPath.includes(pattern))) continue;
+    if (entry.isDirectory()) {
+      if (entry.name === "node_modules" || entry.name === "dist") continue;
+      files.push(...await findTsFiles(fullPath, exclude));
+    } else if (entry.isFile() && /\.(tsx?|jsx?)$/.test(entry.name)) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function extractIconNames(content, componentNames, customPatterns) {
+  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]);
+    }
+  }
+  if (customPatterns) {
+    for (const customPattern of customPatterns) {
+      const pattern = new RegExp(customPattern.pattern, "g");
+      while ((match = pattern.exec(content)) !== null) {
+        const iconName = match[customPattern.captureGroup];
+        if (iconName) {
+          iconNames.add(iconName);
+        }
+      }
+    }
+  }
+  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 generateTypes(config, cwd) {
+  if (!config.types?.enabled) return null;
+  console.log("\n📝 Generating icon types...");
+  const sources = Array.isArray(config.source) ? config.source : [config.source];
+  const allIconNames = [];
+  const sourceInfos = [];
+  const sourceIconSets = /* @__PURE__ */ new Map();
+  for (let i = 0; i < sources.length; i++) {
+    const source = sources[i];
+    if (!source) continue;
+    let iconsDir;
+    let sourceName;
+    if (source.directory) {
+      iconsDir = resolve(cwd, source.directory);
+      sourceName = source.label || source.directory;
+      console.log(`📁 Scanning directory: ${source.directory}`);
+    } else if (source.package) {
+      const packagePath = await findIconPackage(source.package, cwd);
+      iconsDir = join(packagePath, source.iconsPath || "icons");
+      sourceName = source.label || source.package;
+      console.log(`📦 Scanning package: ${source.package}`);
+    } else {
+      throw new Error("Either source.package or source.directory must be specified");
+    }
+    const files = await readdir(iconsDir);
+    const iconNames = files.filter((file) => file.endsWith(".svg")).map((file) => basename(file, ".svg"));
+    console.log(`✓ Found ${iconNames.length} icons from ${sourceName}`);
+    allIconNames.push(...iconNames);
+    sourceInfos.push({ name: sourceName, count: iconNames.length });
+    sourceIconSets.set(i, new Set(iconNames));
+  }
+  const uniqueIconNames = [...new Set(allIconNames)].sort();
+  console.log(`✓ Total unique icons: ${uniqueIconNames.length}`);
+  const typeDefinition = uniqueIconNames.map((name) => `  | '${name}'`).join("\n");
+  const typeName = config.types.typeName || "IconType";
+  const sourceList = sourceInfos.length === 1 && sourceInfos[0] ? sourceInfos[0].name : sourceInfos.map((s) => `${s.name} (${s.count})`).join(", ");
+  const output = `/**
+ * Auto-generated icon type definitions
+ * Sources: ${sourceList}
+ * Total unique icons: ${uniqueIconNames.length}
+ *
+ * @generated by @number10/phaserjsx/generate-icons
+ * @cspell: disable
+ */
+
+/**
+ * All available icon names
+ * Type-only definition - no runtime imports, zero bundle impact
+ */
+export type ${typeName} =
+${typeDefinition}
+`;
+  const outputPath = resolve(cwd, config.types.output);
+  await writeFile(outputPath, output, "utf-8");
+  console.log(`✓ Generated: ${outputPath}`);
+  console.log(`✓ Type name: ${typeName}`);
+  return { iconNames: uniqueIconNames, sourceIconSets };
+}
+async function scanIconSources(config, cwd) {
+  const sources = Array.isArray(config.source) ? config.source : [config.source];
+  const allIconNames = [];
+  const sourceIconSets = /* @__PURE__ */ new Map();
+  for (let i = 0; i < sources.length; i++) {
+    const source = sources[i];
+    if (!source) continue;
+    let iconsDir;
+    if (source.directory) {
+      iconsDir = resolve(cwd, source.directory);
+    } else if (source.package) {
+      const packagePath = await findIconPackage(source.package, cwd);
+      iconsDir = join(packagePath, source.iconsPath || "icons");
+    } else {
+      throw new Error("Either source.package or source.directory must be specified");
+    }
+    const files = await readdir(iconsDir);
+    const iconNames = files.filter((file) => file.endsWith(".svg")).map((file) => basename(file, ".svg"));
+    allIconNames.push(...iconNames);
+    sourceIconSets.set(i, new Set(iconNames));
+  }
+  const uniqueIconNames = [...new Set(allIconNames)].sort();
+  return { iconNames: uniqueIconNames, sourceIconSets };
+}
+async function generateLoaders(config, cwd, typesResult) {
+  if (!config.loaders?.enabled) return;
+  console.log("\n⚡ Generating icon loaders...");
+  const scanDir = resolve(cwd, config.loaders.scanDir);
+  const componentNames = config.loaders.componentNames || ["Icon"];
+  console.log(`📁 Scanning directory: ${scanDir}`);
+  console.log(`🔍 Looking for components: ${componentNames.join(", ")}`);
+  let availableIconsSet = null;
+  let sourceIconSets = null;
+  if (typesResult) {
+    availableIconsSet = new Set(typesResult.iconNames);
+    sourceIconSets = typesResult.sourceIconSets;
+    console.log(`✓ Loaded ${availableIconsSet.size} available icons for validation`);
+  } else if (config.loaders.validate && config.types?.output) {
+    const typesPath = resolve(cwd, config.types.output);
+    availableIconsSet = await loadAvailableIcons(typesPath);
+    if (availableIconsSet) {
+      console.log(`✓ Loaded ${availableIconsSet.size} available icons for validation`);
+    }
+  }
+  const files = await findTsFiles(scanDir, config.exclude);
+  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, config.customPatterns);
+    icons.forEach((icon) => allIconNames.add(icon));
+  }
+  let iconArray = Array.from(allIconNames).sort();
+  if (availableIconsSet) {
+    const invalidIcons = iconArray.filter((icon) => !availableIconsSet.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) => availableIconsSet.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 sources = Array.isArray(config.source) ? config.source : [config.source];
+  const iconSourceMap = /* @__PURE__ */ new Map();
+  for (const icon of iconArray) {
+    if (sourceIconSets) {
+      for (let i = 0; i < sources.length; i++) {
+        const source = sources[i];
+        const iconsForThisSource = sourceIconSets.get(i);
+        if (!source || !iconsForThisSource) continue;
+        if (iconsForThisSource.has(icon)) {
+          let iconPath = "";
+          if (source.package) {
+            const packageName = source.package;
+            const iconsPath = source.iconsPath || "icons";
+            iconPath = `${packageName}/${iconsPath}/${icon}.svg`;
+          } else if (source.directory) {
+            iconPath = `${source.directory}/${icon}.svg`;
+          }
+          if (iconPath) {
+            if (source.directory && config.loaders.output) {
+              const loaderDir = dirname(resolve(cwd, config.loaders.output));
+              const iconAbsPath = resolve(cwd, iconPath);
+              iconPath = relative(loaderDir, iconAbsPath);
+              iconPath = "./" + iconPath.replace(/\\/g, "/");
+            }
+            iconSourceMap.set(icon, {
+              path: iconPath,
+              isPackage: !!source.package
+            });
+            break;
+          }
+        }
+      }
+    } else {
+      for (const source of sources) {
+        let iconPath = "";
+        let exists = false;
+        if (source.package) {
+          const packageName = source.package;
+          const iconsPath = source.iconsPath || "icons";
+          iconPath = `${packageName}/${iconsPath}/${icon}.svg`;
+          exists = availableIconsSet ? availableIconsSet.has(icon) : true;
+        } else if (source.directory) {
+          const dirPath = source.directory;
+          iconPath = `${dirPath}/${icon}.svg`;
+          try {
+            const fullPath = resolve(cwd, dirPath, `${icon}.svg`);
+            await access(fullPath);
+            exists = true;
+          } catch {
+            exists = false;
+          }
+        }
+        if (exists && iconPath) {
+          if (source.directory && config.loaders.output) {
+            const loaderDir = dirname(resolve(cwd, config.loaders.output));
+            const iconAbsPath = resolve(cwd, iconPath);
+            iconPath = relative(loaderDir, iconAbsPath);
+            iconPath = "./" + iconPath.replace(/\\/g, "/");
+          }
+          iconSourceMap.set(icon, {
+            path: iconPath,
+            isPackage: !!source.package
+          });
+          break;
+        }
+      }
+    }
+  }
+  const loaderEntries = Array.from(iconSourceMap.entries()).map(([icon, { path, isPackage }]) => {
+    if (isPackage) {
+      return `  '${icon}': () => import('${path}?raw'),`;
+    } else {
+      return `  '${icon}': () => import('${path}?raw'),`;
+    }
+  });
+  const loaders = loaderEntries.join("\n");
+  const outputContent = `/**
+ * Auto-generated icon loaders
+ * Generated by scanning: ${config.loaders.scanDir}
+ *
+ * @generated by @number10/phaserjsx/generate-icons
+ */
+export type IconLoaderFn = () => Promise<{ default: string }>
+
+export const iconLoaders: Record<string, IconLoaderFn> = {
+${loaders}
+}
+`;
+  const outputPath = resolve(cwd, config.loaders.output);
+  await writeFile(outputPath, outputContent, "utf-8");
+  console.log(`✓ Generated: ${outputPath}`);
+  console.log(`✓ Registered ${iconArray.length} icon loaders`);
+}
+async function loadConfig(configPath, cwd = process.cwd()) {
+  const absolutePath = resolve(cwd, configPath);
+  const fileUrl = pathToFileURL(absolutePath).href;
+  const extension = extname(absolutePath).toLowerCase();
+  try {
+    const module = await import(fileUrl);
+    return module.default || module;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const isUnknownExtension = TS_CONFIG_EXTENSIONS.has(extension) || errorMessage.includes("Unknown file extension");
+    if (isUnknownExtension) {
+      try {
+        const { tsImport } = await import("tsx/esm/api");
+        const module = await tsImport(fileUrl, import.meta.url);
+        return module.default || module;
+      } catch (tsxError) {
+        const tsxMessage = tsxError instanceof Error ? tsxError.message : String(tsxError);
+        throw new Error(
+          `Failed to load config from ${configPath}: ${tsxMessage} (after tsx fallback)`
+        );
+      }
+    }
+    throw new Error(`Failed to load config from ${configPath}: ${errorMessage}`);
+  }
+}
+async function runGeneration(config, cwd) {
+  console.log("🎨 Icon Generator");
+  console.log("─".repeat(50));
+  const typesResult = await generateTypes(config, cwd);
+  await generateLoaders(config, cwd, typesResult || void 0);
+  console.log("\n✨ Done!\n");
+}
+async function watchMode(config, cwd) {
+  console.log("👁️  Watch mode enabled");
+  console.log("📁 Monitoring for changes...\n");
+  await runGeneration(config, cwd);
+  const watchDirs = /* @__PURE__ */ new Set();
+  if (config.loaders?.enabled) {
+    const scanDir = resolve(cwd, config.loaders.scanDir);
+    watchDirs.add(scanDir);
+  }
+  const sources = Array.isArray(config.source) ? config.source : [config.source];
+  for (const source of sources) {
+    if (source.directory) {
+      watchDirs.add(resolve(cwd, source.directory));
+    }
+  }
+  let regenerateTimeout = null;
+  const scheduleRegenerate = () => {
+    if (regenerateTimeout) {
+      clearTimeout(regenerateTimeout);
+    }
+    regenerateTimeout = setTimeout(async () => {
+      console.log("\n🔄 Changes detected, regenerating...");
+      try {
+        await runGeneration(config, cwd);
+      } catch (error) {
+        console.error("❌ Error during regeneration:", error);
+      }
+    }, 300);
+  };
+  for (const dir of watchDirs) {
+    const watcher = watch(dir, { recursive: true }, (eventType, filename) => {
+      if (!filename) return;
+      if (filename.includes("node_modules") || filename.includes(".git") || filename.endsWith(".generated.ts") || filename.startsWith(".")) {
+        return;
+      }
+      if (/\.(tsx?|svg)$/.test(filename)) {
+        console.log(`📝 ${eventType}: ${filename}`);
+        scheduleRegenerate();
+      }
+    });
+    watcher.on("error", (error) => {
+      console.error(`❌ Watch error for ${dir}:`, error);
+    });
+  }
+  console.log(`👀 Watching ${watchDirs.size} directories`);
+  console.log("Press Ctrl+C to stop\n");
+  await new Promise(() => {
+  });
+}
+async function main() {
+  const { values } = parseArgs({
+    options: {
+      config: { type: "string", short: "c" },
+      typesOnly: { type: "boolean" },
+      loadersOnly: { type: "boolean" },
+      watch: { type: "boolean", short: "w" },
+      help: { type: "boolean", short: "h" }
+    }
+  });
+  if (values.help) {
+    console.log(`
+Usage: generate-icons [options]
+
+Options:
+  -c, --config <path>     Path to config file (e.g., ./icon-generator.config.ts)
+  --typesOnly             Only generate types (skip loaders)
+  --loadersOnly           Only generate loaders (skip types)
+  -h, --help              Show this help message
+
+Config File Example:
+  // icon-generator.config.ts
+  import { defineIconConfig } from '@number10/phaserjsx/scripts/icon-generator-config'
+
+  export default defineIconConfig({
+    source: {
+      package: 'bootstrap-icons',
+      iconsPath: 'icons',
+    },
+    types: {
+      enabled: true,
+      output: './src/icon-types.generated.ts',
+      typeName: 'IconType',
+    },
+    loaders: {
+      enabled: true,
+      output: './src/icon-loaders.generated.ts',
+      scanDir: './src',
+      componentNames: ['Icon', 'BootstrapIcon'],
+      validate: true,
+    },
+  })
+
+Examples:
+  # Using config file
+  generate-icons --config ./icon-generator.config.ts
+
+  # Generate only types
+  generate-icons --config ./icon-generator.config.ts --typesOnly
+
+  # Generate only loaders
+  generate-icons --config ./icon-generator.config.ts --loadersOnly
+
+  # Watch mode - regenerate on file changes
+  generate-icons --config ./icon-generator.config.ts --watch
+`);
+    process.exit(0);
+  }
+  if (!values.config) {
+    console.error("❌ Error: --config is required");
+    console.error("Run with --help for usage information");
+    process.exit(1);
+  }
+  try {
+    const cwd = process.cwd();
+    let config = await loadConfig(values.config);
+    if (values.typesOnly && config.loaders) {
+      config = { ...config, loaders: { ...config.loaders, enabled: false } };
+    }
+    if (values.loadersOnly && config.types) {
+      config = { ...config, types: { ...config.types, enabled: false } };
+    }
+    if (values.watch) {
+      await watchMode(config, cwd);
+    } else {
+      await runGeneration(config, cwd);
+    }
+  } catch (error) {
+    console.error("❌ Error:", error);
+    process.exit(1);
+  }
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}
+export {
+  generateLoaders,
+  generateTypes,
+  loadConfig,
+  scanIconSources
+};

package/dist/scripts/icon-generator-config.d.ts

@@ -0,0 +1,87 @@
+/**
+ * Configuration schema for icon generators
+ * This file defines the TypeScript types for icon-generator.config.ts
+ */
+/**
+ * Source configuration - where to find icons
+ */
+export interface IconSource {
+    /** Icon package name from node_modules (e.g., 'bootstrap-icons') */
+    package?: string;
+    /** Local directory with SVG files (alternative to package) */
+    directory?: string;
+    /** Relative path to icons within package (default: 'icons') */
+    iconsPath?: string;
+    /** Optional label for this source (used in logs for multi-source) */
+    label?: string;
+}
+/**
+ * Type generation configuration
+ */
+export interface TypesConfig {
+    /** Enable types generation */
+    enabled: boolean;
+    /** Output file path for generated types */
+    output: string;
+    /** TypeScript type name (default: 'IconType') */
+    typeName?: string;
+    /**
+     * When to scan icon directories (Vite plugin only)
+     * - 'never': Never scan (types must be generated manually)
+     * - 'start': Scan once at startup
+     * - 'watch': Scan at startup and on SVG file changes (default)
+     */
+    scanIconDirectory?: 'never' | 'start' | 'watch';
+}
+/**
+ * Loader generation configuration
+ */
+export interface LoadersConfig {
+    /** Enable loaders generation */
+    enabled: boolean;
+    /** Output file path for generated loaders */
+    output: string;
+    /** Source directory to scan for icon usage */
+    scanDir: string;
+    /** Component names to search for (e.g., ['Icon', 'BootstrapIcon']) */
+    componentNames?: string[];
+    /** Validate against types file (enables warnings for invalid icons) */
+    validate?: boolean;
+    /**
+     * When to generate loaders (Vite plugin only)
+     * - 'start': Generate once at startup
+     * - 'watch': Generate at startup and on code file changes (default)
+     */
+    generateLoaders?: 'start' | 'watch';
+}
+/**
+ * Custom pattern for detecting icon usage
+ */
+export interface CustomPattern {
+    /** Pattern name/description */
+    name: string;
+    /** Regex pattern as string (will be compiled with 'g' flag) */
+    pattern: string;
+    /** Capture group index for icon name (1-based) */
+    captureGroup: number;
+}
+/**
+ * Main configuration for icon generator
+ */
+export interface IconGeneratorConfig {
+    /** Icon source configuration - single source or array of sources */
+    source: IconSource | IconSource[];
+    /** Type generation configuration */
+    types?: TypesConfig;
+    /** Loader generation configuration */
+    loaders?: LoadersConfig;
+    /** Custom patterns for detecting icon usage in loaders */
+    customPatterns?: CustomPattern[];
+    /** Exclude patterns (glob) when scanning for icons */
+    exclude?: string[];
+}
+/**
+ * Helper function to define config with type safety
+ */
+export declare function defineIconConfig(config: IconGeneratorConfig): IconGeneratorConfig;
+//# sourceMappingURL=icon-generator-config.d.ts.map

package/dist/scripts/icon-generator-config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"icon-generator-config.d.ts","sourceRoot":"","sources":["../../src/scripts/icon-generator-config.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,oEAAoE;IACpE,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,8DAA8D;IAC9D,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,+DAA+D;IAC/D,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,qEAAqE;IACrE,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,8BAA8B;IAC9B,OAAO,EAAE,OAAO,CAAA;IAChB,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAA;IACd,iDAAiD;IACjD,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAA;CAChD;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,gCAAgC;IAChC,OAAO,EAAE,OAAO,CAAA;IAChB,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAA;IACd,8CAA8C;IAC9C,OAAO,EAAE,MAAM,CAAA;IACf,sEAAsE;IACtE,cAAc,CAAC,EAAE,MAAM,EAAE,CAAA;IACzB,uEAAuE;IACvE,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,GAAG,OAAO,CAAA;CACpC;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,+DAA+D;IAC/D,OAAO,EAAE,MAAM,CAAA;IACf,kDAAkD;IAClD,YAAY,EAAE,MAAM,CAAA;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,oEAAoE;IACpE,MAAM,EAAE,UAAU,GAAG,UAAU,EAAE,CAAA;IAEjC,oCAAoC;IACpC,KAAK,CAAC,EAAE,WAAW,CAAA;IAEnB,sCAAsC;IACtC,OAAO,CAAC,EAAE,aAAa,CAAA;IAEvB,0DAA0D;IAC1D,cAAc,CAAC,EAAE,aAAa,EAAE,CAAA;IAEhC,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CACnB;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,mBAAmB,GAAG,mBAAmB,CAEjF"}

package/dist/scripts/icon-generator-config.js

@@ -0,0 +1,6 @@
+function defineIconConfig(config) {
+  return config;
+}
+export {
+  defineIconConfig
+};