@pro-laico/payload-icons 0.0.0

package/dist/scan/extract.js

@@ -0,0 +1,286 @@
+/**
+ * Pure, dependency-free extraction of literal icon names from one source file's
+ * text. This is the core of the build-time usage scan that powers the admin
+ * "requested icons" panel — kept side-effect-free (no `fs`) so it is trivially
+ * unit-testable and reusable from any walker.
+ *
+ * It is tag-aware, NOT a naive regex. The scanner walks the file skipping
+ * strings and comments, and for every `<Icon …>` opening tag it parses the
+ * attribute list, so a `>` inside an expression (`check={a > b}`) or a `name`
+ * substring inside a sibling attribute (`iconName`, `data-name`) never trips
+ * it.
+ *
+ * ONLY string-literal names are collected — the value must resolve statically:
+ *   - `name="x"` / `name='x'`            (direct attribute strings)
+ *   - `name={"x"}` / `name={'x'}`        (string literal in an expression slot)
+ *   - `` name={`x`} ``                   (template literal, no interpolation)
+ * Dynamic `name={expr}` (variables, concatenation, interpolated templates) is
+ * intentionally skipped — a static scan cannot know its value.
+ */ /** A single literal `<Icon name="…">` occurrence found in a file. */ const DEFAULT_COMPONENTS = [
+    'Icon'
+];
+/** Plausible icon names only — set-row names are kebab-cased, so prose placeholders (`…`) never qualify. */ const PLAUSIBLE_NAME = /^[\w-]+$/;
+const isWhitespace = (c)=>c === ' ' || c === '\t' || c === '\n' || c === '\r' || c === '\f' || c === '\v';
+const isIdentStart = (c)=>/[A-Za-z_$]/.test(c);
+const isTagNameBoundary = (c)=>c === undefined || isWhitespace(c) || c === '/' || c === '>';
+/** Builds a binary-searchable index of line-start offsets for fast line/column lookup. */ const buildLineIndex = (source)=>{
+    const starts = [
+        0
+    ];
+    for(let i = 0; i < source.length; i++)if (source[i] === '\n') starts.push(i + 1);
+    return starts;
+};
+const lineColAt = (lineStarts, index)=>{
+    // Binary search for the greatest line-start <= index.
+    let lo = 0;
+    let hi = lineStarts.length - 1;
+    while(lo < hi){
+        const mid = lo + hi + 1 >> 1;
+        if (lineStarts[mid] <= index) lo = mid;
+        else hi = mid - 1;
+    }
+    return {
+        line: lo + 1,
+        column: index - lineStarts[lo] + 1
+    };
+};
+/** Skips a `"…"` / `'…'` string starting at `i` (the opening quote). Returns the index just past the closing quote. */ const skipString = (source, i)=>{
+    const quote = source[i];
+    i++;
+    while(i < source.length){
+        const c = source[i];
+        if (c === '\\') {
+            i += 2;
+            continue;
+        }
+        if (c === quote) return i + 1;
+        i++;
+    }
+    return i;
+};
+/** Skips a `` `…` `` template (including nested `${ … }`) starting at the opening backtick. Returns the index just past the closing backtick. */ const skipTemplate = (source, i)=>{
+    i++;
+    while(i < source.length){
+        const c = source[i];
+        if (c === '\\') {
+            i += 2;
+            continue;
+        }
+        if (c === '`') return i + 1;
+        if (c === '$' && source[i + 1] === '{') {
+            i = skipBraces(source, i + 1);
+            continue;
+        }
+        i++;
+    }
+    return i;
+};
+/** Skips a balanced `{ … }` region starting at the opening brace, honoring nested braces, strings, templates, and comments. Returns the index just past the closing brace. */ const skipBraces = (source, i)=>{
+    let depth = 0;
+    while(i < source.length){
+        const c = source[i];
+        if (c === '"' || c === "'") {
+            i = skipString(source, i);
+            continue;
+        }
+        if (c === '`') {
+            i = skipTemplate(source, i);
+            continue;
+        }
+        if (c === '/' && source[i + 1] === '/') {
+            i = skipLineComment(source, i);
+            continue;
+        }
+        if (c === '/' && source[i + 1] === '*') {
+            i = skipBlockComment(source, i);
+            continue;
+        }
+        if (c === '{') depth++;
+        else if (c === '}') {
+            depth--;
+            if (depth === 0) return i + 1;
+        }
+        i++;
+    }
+    return i;
+};
+const skipLineComment = (source, i)=>{
+    i += 2;
+    while(i < source.length && source[i] !== '\n')i++;
+    return i;
+};
+const skipBlockComment = (source, i)=>{
+    i += 2;
+    while(i < source.length && !(source[i] === '*' && source[i + 1] === '/'))i++;
+    return Math.min(i + 2, source.length);
+};
+/**
+ * Interprets a JSX attribute expression container's INNER text (the part
+ * between `{` and `}`). Returns the literal string if the whole expression is a
+ * single string or non-interpolated template literal, otherwise `null`
+ * (dynamic — skipped).
+ */ const interpretExpression = (inner)=>{
+    const expr = inner.trim();
+    if (expr.length < 2) return null;
+    const first = expr[0];
+    const last = expr[expr.length - 1];
+    if ((first === '"' || first === "'") && last === first) {
+        // Must be a SINGLE string literal — reject concatenation like `"a" + b`.
+        if (skipString(expr, 0) !== expr.length) return null;
+        return unquote(expr);
+    }
+    if (first === '`' && last === '`') {
+        if (skipTemplate(expr, 0) !== expr.length) return null;
+        if (expr.includes('${')) return null // interpolated — dynamic
+        ;
+        return expr.slice(1, -1);
+    }
+    return null;
+};
+/** Decodes a quoted string literal's escapes into its runtime value. */ const unquote = (literal)=>{
+    const body = literal.slice(1, -1);
+    return body.replace(/\\(.)/g, (_, ch)=>{
+        switch(ch){
+            case 'n':
+                return '\n';
+            case 't':
+                return '\t';
+            case 'r':
+                return '\r';
+            default:
+                return ch;
+        }
+    });
+};
+/**
+ * Parses the attribute list of an `<Icon …>` opening tag and, if a literal
+ * `name` is present, returns it with the absolute source index of its value.
+ *
+ * @param source full file text
+ * @param start index of the first attribute char (just past the tag name)
+ * @returns the literal name + value index, or `null` if absent/dynamic
+ */ const parseNameAttr = (source, start)=>{
+    let i = start;
+    while(i < source.length){
+        const c = source.charAt(i);
+        if (isWhitespace(c)) {
+            i++;
+            continue;
+        }
+        if (c === '>') return null // end of opening tag, no name found
+        ;
+        if (c === '/' && source[i + 1] === '>') return null // self-closing, no name
+        ;
+        if (c === '{') {
+            // Spread attribute `{...props}` — skip it wholesale.
+            i = skipBraces(source, i);
+            continue;
+        }
+        if (!isIdentStart(c) && c !== '-') {
+            i++;
+            continue;
+        }
+        // Read an attribute name.
+        const attrStart = i;
+        while(i < source.length && /[\w:-]/.test(source.charAt(i)))i++;
+        const attrName = source.slice(attrStart, i);
+        // Skip whitespace before a possible `=`.
+        let j = i;
+        while(j < source.length && isWhitespace(source.charAt(j)))j++;
+        if (source[j] !== '=') {
+            // Boolean attribute (no value) — continue scanning from here.
+            i = j;
+            continue;
+        }
+        j++; // past '='
+        while(j < source.length && isWhitespace(source.charAt(j)))j++;
+        const valChar = source[j];
+        let valueIndex = j;
+        let value;
+        if (valChar === '"' || valChar === "'") {
+            const end = skipString(source, j);
+            value = unquote(source.slice(j, end));
+            i = end;
+        } else if (valChar === '{') {
+            const end = skipBraces(source, j);
+            value = interpretExpression(source.slice(j + 1, end - 1));
+            valueIndex = j + 1;
+            i = end;
+        } else {
+            // Malformed/unexpected — bail on this tag.
+            return null;
+        }
+        if (attrName === 'name') {
+            return value === null ? null : {
+                name: value,
+                index: valueIndex
+            };
+        }
+    }
+    return null;
+};
+/**
+ * Extracts every literal icon-name usage from a single file's source text.
+ * See the module doc for what counts as a literal. Returns occurrences in
+ * source order; de-duplication across files happens in the aggregator.
+ *
+ * The scan looks directly for `<Icon …>` tag starts and parses each opening tag
+ * with full string/brace awareness (so the `name` value and the tag's end are
+ * found correctly). It deliberately does NOT try to mask surrounding strings or
+ * comments: JSX text routinely contains apostrophes (`it's`) and `//` (`http://`)
+ * that a whole-file lexer would mis-read as a string/comment and skip a real
+ * usage past. Instead, two surgical guards keep commentary out without a lexer:
+ * a candidate whose line leads with `//` or `*` (line comments, JSDoc
+ * continuations — real JSX never starts a line that way) is skipped, and
+ * extracted names must look like icon names ({@link PLAUSIBLE_NAME}), so prose
+ * placeholders like `…` are dropped. An `<Icon name="…">` written literally in
+ * a JS string (or a mid-line comment) can still be picked up — a harmless
+ * over-count for an inventory, where missing a real usage would be the worse
+ * failure.
+ */ export const extractIconUsages = (source, options = {})=>{
+    const components = options.components?.length ? options.components : DEFAULT_COMPONENTS;
+    const componentSet = new Set(components);
+    const lineStarts = buildLineIndex(source);
+    const usages = [];
+    const n = source.length;
+    let i = 0;
+    while(i < n){
+        if (source[i] !== '<') {
+            i++;
+            continue;
+        }
+        // Candidate opening tag — read the tag name and check it against the set.
+        let k = i + 1;
+        if (k >= n || !isIdentStart(source.charAt(k))) {
+            i++;
+            continue;
+        }
+        const nameStart = k;
+        while(k < n && /[\w.]/.test(source.charAt(k)))k++;
+        const tagName = source.slice(nameStart, k);
+        if (!componentSet.has(tagName) || !isTagNameBoundary(source[k])) {
+            i = k;
+            continue;
+        }
+        // Comment guard: only the text between the line start and this `<` counts,
+        // so a URL's `//` earlier on the line never triggers a false skip.
+        const linePrefix = source.slice(source.lastIndexOf('\n', i - 1) + 1, i).trimStart();
+        if (linePrefix.startsWith('//') || linePrefix.startsWith('*')) {
+            i = k;
+            continue;
+        }
+        const found = parseNameAttr(source, k);
+        if (found && PLAUSIBLE_NAME.test(found.name.trim())) {
+            const { line, column } = lineColAt(lineStarts, found.index);
+            usages.push({
+                name: found.name.trim(),
+                line,
+                column
+            });
+        }
+        i = k;
+    }
+    return usages;
+};
+
+//# sourceMappingURL=extract.js.map

package/dist/scan/extract.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/scan/extract.ts"],"sourcesContent":["/**\n * Pure, dependency-free extraction of literal icon names from one source file's\n * text. This is the core of the build-time usage scan that powers the admin\n * \"requested icons\" panel — kept side-effect-free (no `fs`) so it is trivially\n * unit-testable and reusable from any walker.\n *\n * It is tag-aware, NOT a naive regex. The scanner walks the file skipping\n * strings and comments, and for every `<Icon …>` opening tag it parses the\n * attribute list, so a `>` inside an expression (`check={a > b}`) or a `name`\n * substring inside a sibling attribute (`iconName`, `data-name`) never trips\n * it.\n *\n * ONLY string-literal names are collected — the value must resolve statically:\n *   - `name=\"x\"` / `name='x'`            (direct attribute strings)\n *   - `name={\"x\"}` / `name={'x'}`        (string literal in an expression slot)\n *   - `` name={`x`} ``                   (template literal, no interpolation)\n * Dynamic `name={expr}` (variables, concatenation, interpolated templates) is\n * intentionally skipped — a static scan cannot know its value.\n */\n\n/** A single literal `<Icon name=\"…\">` occurrence found in a file. */\nexport interface ExtractedUsage {\n  /** The resolved literal icon name. */\n  name: string\n  /** 1-based line of the `name` value. */\n  line: number\n  /** 1-based column of the `name` value. */\n  column: number\n}\n\nexport interface ExtractOptions {\n  /**\n   * JSX tag names treated as icon usages. Matched exactly against the opening\n   * tag name, so `Icon` matches `<Icon …>` but not `<MyIcon …>`.\n   *\n   * @default ['Icon']\n   */\n  components?: string[]\n}\n\nconst DEFAULT_COMPONENTS = ['Icon']\n\n/** Plausible icon names only — set-row names are kebab-cased, so prose placeholders (`…`) never qualify. */\nconst PLAUSIBLE_NAME = /^[\\w-]+$/\n\nconst isWhitespace = (c: string): boolean => c === ' ' || c === '\\t' || c === '\\n' || c === '\\r' || c === '\\f' || c === '\\v'\nconst isIdentStart = (c: string): boolean => /[A-Za-z_$]/.test(c)\nconst isTagNameBoundary = (c: string | undefined): boolean => c === undefined || isWhitespace(c) || c === '/' || c === '>'\n\n/** Builds a binary-searchable index of line-start offsets for fast line/column lookup. */\nconst buildLineIndex = (source: string): number[] => {\n  const starts = [0]\n  for (let i = 0; i < source.length; i++) if (source[i] === '\\n') starts.push(i + 1)\n  return starts\n}\n\nconst lineColAt = (lineStarts: number[], index: number): { line: number; column: number } => {\n  // Binary search for the greatest line-start <= index.\n  let lo = 0\n  let hi = lineStarts.length - 1\n  while (lo < hi) {\n    const mid = (lo + hi + 1) >> 1\n    if ((lineStarts[mid] as number) <= index) lo = mid\n    else hi = mid - 1\n  }\n  return { line: lo + 1, column: index - (lineStarts[lo] as number) + 1 }\n}\n\n/** Skips a `\"…\"` / `'…'` string starting at `i` (the opening quote). Returns the index just past the closing quote. */\nconst skipString = (source: string, i: number): number => {\n  const quote = source[i]\n  i++\n  while (i < source.length) {\n    const c = source[i]\n    if (c === '\\\\') {\n      i += 2\n      continue\n    }\n    if (c === quote) return i + 1\n    i++\n  }\n  return i\n}\n\n/** Skips a `` `…` `` template (including nested `${ … }`) starting at the opening backtick. Returns the index just past the closing backtick. */\nconst skipTemplate = (source: string, i: number): number => {\n  i++\n  while (i < source.length) {\n    const c = source[i]\n    if (c === '\\\\') {\n      i += 2\n      continue\n    }\n    if (c === '`') return i + 1\n    if (c === '$' && source[i + 1] === '{') {\n      i = skipBraces(source, i + 1)\n      continue\n    }\n    i++\n  }\n  return i\n}\n\n/** Skips a balanced `{ … }` region starting at the opening brace, honoring nested braces, strings, templates, and comments. Returns the index just past the closing brace. */\nconst skipBraces = (source: string, i: number): number => {\n  let depth = 0\n  while (i < source.length) {\n    const c = source[i]\n    if (c === '\"' || c === \"'\") {\n      i = skipString(source, i)\n      continue\n    }\n    if (c === '`') {\n      i = skipTemplate(source, i)\n      continue\n    }\n    if (c === '/' && source[i + 1] === '/') {\n      i = skipLineComment(source, i)\n      continue\n    }\n    if (c === '/' && source[i + 1] === '*') {\n      i = skipBlockComment(source, i)\n      continue\n    }\n    if (c === '{') depth++\n    else if (c === '}') {\n      depth--\n      if (depth === 0) return i + 1\n    }\n    i++\n  }\n  return i\n}\n\nconst skipLineComment = (source: string, i: number): number => {\n  i += 2\n  while (i < source.length && source[i] !== '\\n') i++\n  return i\n}\n\nconst skipBlockComment = (source: string, i: number): number => {\n  i += 2\n  while (i < source.length && !(source[i] === '*' && source[i + 1] === '/')) i++\n  return Math.min(i + 2, source.length)\n}\n\n/**\n * Interprets a JSX attribute expression container's INNER text (the part\n * between `{` and `}`). Returns the literal string if the whole expression is a\n * single string or non-interpolated template literal, otherwise `null`\n * (dynamic — skipped).\n */\nconst interpretExpression = (inner: string): string | null => {\n  const expr = inner.trim()\n  if (expr.length < 2) return null\n  const first = expr[0]\n  const last = expr[expr.length - 1]\n  if ((first === '\"' || first === \"'\") && last === first) {\n    // Must be a SINGLE string literal — reject concatenation like `\"a\" + b`.\n    if (skipString(expr, 0) !== expr.length) return null\n    return unquote(expr)\n  }\n  if (first === '`' && last === '`') {\n    if (skipTemplate(expr, 0) !== expr.length) return null\n    if (expr.includes('${')) return null // interpolated — dynamic\n    return expr.slice(1, -1)\n  }\n  return null\n}\n\n/** Decodes a quoted string literal's escapes into its runtime value. */\nconst unquote = (literal: string): string => {\n  const body = literal.slice(1, -1)\n  return body.replace(/\\\\(.)/g, (_, ch: string) => {\n    switch (ch) {\n      case 'n':\n        return '\\n'\n      case 't':\n        return '\\t'\n      case 'r':\n        return '\\r'\n      default:\n        return ch\n    }\n  })\n}\n\n/**\n * Parses the attribute list of an `<Icon …>` opening tag and, if a literal\n * `name` is present, returns it with the absolute source index of its value.\n *\n * @param source full file text\n * @param start index of the first attribute char (just past the tag name)\n * @returns the literal name + value index, or `null` if absent/dynamic\n */\nconst parseNameAttr = (source: string, start: number): { name: string; index: number } | null => {\n  let i = start\n  while (i < source.length) {\n    const c = source.charAt(i)\n    if (isWhitespace(c)) {\n      i++\n      continue\n    }\n    if (c === '>') return null // end of opening tag, no name found\n    if (c === '/' && source[i + 1] === '>') return null // self-closing, no name\n    if (c === '{') {\n      // Spread attribute `{...props}` — skip it wholesale.\n      i = skipBraces(source, i)\n      continue\n    }\n    if (!isIdentStart(c) && c !== '-') {\n      i++\n      continue\n    }\n    // Read an attribute name.\n    const attrStart = i\n    while (i < source.length && /[\\w:-]/.test(source.charAt(i))) i++\n    const attrName = source.slice(attrStart, i)\n    // Skip whitespace before a possible `=`.\n    let j = i\n    while (j < source.length && isWhitespace(source.charAt(j))) j++\n    if (source[j] !== '=') {\n      // Boolean attribute (no value) — continue scanning from here.\n      i = j\n      continue\n    }\n    j++ // past '='\n    while (j < source.length && isWhitespace(source.charAt(j))) j++\n    const valChar = source[j]\n    let valueIndex = j\n    let value: string | null\n    if (valChar === '\"' || valChar === \"'\") {\n      const end = skipString(source, j)\n      value = unquote(source.slice(j, end))\n      i = end\n    } else if (valChar === '{') {\n      const end = skipBraces(source, j)\n      value = interpretExpression(source.slice(j + 1, end - 1))\n      valueIndex = j + 1\n      i = end\n    } else {\n      // Malformed/unexpected — bail on this tag.\n      return null\n    }\n    if (attrName === 'name') {\n      return value === null ? null : { name: value, index: valueIndex }\n    }\n  }\n  return null\n}\n\n/**\n * Extracts every literal icon-name usage from a single file's source text.\n * See the module doc for what counts as a literal. Returns occurrences in\n * source order; de-duplication across files happens in the aggregator.\n *\n * The scan looks directly for `<Icon …>` tag starts and parses each opening tag\n * with full string/brace awareness (so the `name` value and the tag's end are\n * found correctly). It deliberately does NOT try to mask surrounding strings or\n * comments: JSX text routinely contains apostrophes (`it's`) and `//` (`http://`)\n * that a whole-file lexer would mis-read as a string/comment and skip a real\n * usage past. Instead, two surgical guards keep commentary out without a lexer:\n * a candidate whose line leads with `//` or `*` (line comments, JSDoc\n * continuations — real JSX never starts a line that way) is skipped, and\n * extracted names must look like icon names ({@link PLAUSIBLE_NAME}), so prose\n * placeholders like `…` are dropped. An `<Icon name=\"…\">` written literally in\n * a JS string (or a mid-line comment) can still be picked up — a harmless\n * over-count for an inventory, where missing a real usage would be the worse\n * failure.\n */\nexport const extractIconUsages = (source: string, options: ExtractOptions = {}): ExtractedUsage[] => {\n  const components = options.components?.length ? options.components : DEFAULT_COMPONENTS\n  const componentSet = new Set(components)\n  const lineStarts = buildLineIndex(source)\n  const usages: ExtractedUsage[] = []\n  const n = source.length\n  let i = 0\n\n  while (i < n) {\n    if (source[i] !== '<') {\n      i++\n      continue\n    }\n    // Candidate opening tag — read the tag name and check it against the set.\n    let k = i + 1\n    if (k >= n || !isIdentStart(source.charAt(k))) {\n      i++\n      continue\n    }\n    const nameStart = k\n    while (k < n && /[\\w.]/.test(source.charAt(k))) k++\n    const tagName = source.slice(nameStart, k)\n    if (!componentSet.has(tagName) || !isTagNameBoundary(source[k])) {\n      i = k\n      continue\n    }\n    // Comment guard: only the text between the line start and this `<` counts,\n    // so a URL's `//` earlier on the line never triggers a false skip.\n    const linePrefix = source.slice(source.lastIndexOf('\\n', i - 1) + 1, i).trimStart()\n    if (linePrefix.startsWith('//') || linePrefix.startsWith('*')) {\n      i = k\n      continue\n    }\n    const found = parseNameAttr(source, k)\n    if (found && PLAUSIBLE_NAME.test(found.name.trim())) {\n      const { line, column } = lineColAt(lineStarts, found.index)\n      usages.push({ name: found.name.trim(), line, column })\n    }\n    i = k\n  }\n\n  return usages\n}\n"],"names":["DEFAULT_COMPONENTS","PLAUSIBLE_NAME","isWhitespace","c","isIdentStart","test","isTagNameBoundary","undefined","buildLineIndex","source","starts","i","length","push","lineColAt","lineStarts","index","lo","hi","mid","line","column","skipString","quote","skipTemplate","skipBraces","depth","skipLineComment","skipBlockComment","Math","min","interpretExpression","inner","expr","trim","first","last","unquote","includes","slice","literal","body","replace","_","ch","parseNameAttr","start","charAt","attrStart","attrName","j","valChar","valueIndex","value","end","name","extractIconUsages","options","components","componentSet","Set","usages","n","k","nameStart","tagName","has","linePrefix","lastIndexOf","trimStart","startsWith","found"],"mappings":"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"}

package/dist/scan/index.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Build-time icon-usage scan — the Node-side entry point. Walks a project's
+ * source tree, extracts every literal `<Icon name="…">` (see {@link extractIconUsages}),
+ * and aggregates the result into an {@link IconUsageManifest} that the admin
+ * "requested icons" panel reads.
+ *
+ * Zero third-party dependencies: directory walking uses `node:fs` directly so
+ * the package adds nothing to a consumer's install for this feature.
+ */
+import type { IconUsageManifest } from './types.js';
+export { extractIconUsages } from './extract.js';
+export type { ExtractedUsage, ExtractOptions } from './extract.js';
+export type { IconUsage, IconUsageManifest } from './types.js';
+export { DEFAULT_MANIFEST_FILENAME, loadIconUsageManifest, MANIFEST_PATH_ENV, resolveManifestPath } from './load.js';
+/** Root directories scanned by default. */
+export declare const DEFAULT_ROOTS: string[];
+/** File extensions scanned by default — the JSX-bearing source formats. */
+export declare const DEFAULT_EXTENSIONS: string[];
+/** Directory names never descended into. */
+export declare const DEFAULT_IGNORE: string[];
+export interface ScanOptions {
+    /**
+     * Directories (or individual files) to scan, relative to {@link cwd} or
+     * absolute. Each directory is walked recursively.
+     *
+     * @default ['src', 'app']
+     */
+    roots?: string[];
+    /**
+     * Working directory the scan resolves {@link roots} and reports file paths
+     * relative to.
+     *
+     * @default process.cwd()
+     */
+    cwd?: string;
+    /**
+     * JSX tag names treated as icon usages. Forwarded to {@link extractIconUsages}.
+     *
+     * @default ['Icon']
+     */
+    components?: string[];
+    /**
+     * File extensions (without the dot) to read.
+     *
+     * @default ['tsx', 'jsx', 'ts', 'js', 'mdx']
+     */
+    extensions?: string[];
+    /**
+     * Directory names to skip while walking.
+     *
+     * @default ['node_modules', '.next', '.git', 'dist', 'build', 'coverage', '.turbo']
+     */
+    ignore?: string[];
+}
+/** The result of a {@link scanIconUsages} run. */
+export interface ScanResult {
+    /** The assembled manifest, ready to write. */
+    manifest: IconUsageManifest;
+    /** Number of files read during the scan. */
+    filesScanned: number;
+    /** Number of scan roots that actually existed — `0` means every root was missing (wrong cwd?). */
+    rootsScanned: number;
+}
+/**
+ * Scans the project for literal icon usages and builds a manifest. Pure with
+ * respect to output (writes nothing) — use {@link writeIconUsageManifest} to
+ * persist the result.
+ *
+ * @example
+ * ```ts
+ * const { manifest } = scanIconUsages({ roots: ['src', 'app'] })
+ * console.log(manifest.names) // ['arrow-right', 'chevron', 'x', …]
+ * ```
+ */
+export declare const scanIconUsages: (options?: ScanOptions) => ScanResult;
+/**
+ * Writes a manifest to disk as pretty-printed JSON (trailing newline). Returns
+ * the absolute path written.
+ */
+export declare const writeIconUsageManifest: (manifest: IconUsageManifest, path: string) => string;
+//# sourceMappingURL=index.d.ts.map

package/dist/scan/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/scan/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAMH,OAAO,KAAK,EAAa,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAE9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAChD,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAClE,YAAY,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AAI9D,OAAO,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAA;AAEpH,2CAA2C;AAC3C,eAAO,MAAM,aAAa,UAAiB,CAAA;AAE3C,2EAA2E;AAC3E,eAAO,MAAM,kBAAkB,UAAoC,CAAA;AAEnE,4CAA4C;AAC5C,eAAO,MAAM,cAAc,UAA2E,CAAA;AAEtG,MAAM,WAAW,WAAW;IAC1B;;;;;OAKG;IACH,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;IAChB;;;;;OAKG;IACH,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;IACrB;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;IACrB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;CAClB;AAuBD,kDAAkD;AAClD,MAAM,WAAW,UAAU;IACzB,8CAA8C;IAC9C,QAAQ,EAAE,iBAAiB,CAAA;IAC3B,4CAA4C;IAC5C,YAAY,EAAE,MAAM,CAAA;IACpB,kGAAkG;IAClG,YAAY,EAAE,MAAM,CAAA;CACrB;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,GAAI,UAAS,WAAgB,KAAG,UA8C1D,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,sBAAsB,GAAI,UAAU,iBAAiB,EAAE,MAAM,MAAM,KAAG,MAIlF,CAAA"}

package/dist/scan/index.js

@@ -0,0 +1,133 @@
+/**
+ * Build-time icon-usage scan — the Node-side entry point. Walks a project's
+ * source tree, extracts every literal `<Icon name="…">` (see {@link extractIconUsages}),
+ * and aggregates the result into an {@link IconUsageManifest} that the admin
+ * "requested icons" panel reads.
+ *
+ * Zero third-party dependencies: directory walking uses `node:fs` directly so
+ * the package adds nothing to a consumer's install for this feature.
+ */ import { readdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { extractIconUsages } from "./extract.js";
+export { extractIconUsages } from "./extract.js";
+// Manifest path resolution + reading live in ./load (a bundler-safe leaf with no
+// runtime relative imports) so the admin panel can import them without pulling
+// in this CLI/parser module. Re-exported here to keep the `./scan` API in one place.
+export { DEFAULT_MANIFEST_FILENAME, loadIconUsageManifest, MANIFEST_PATH_ENV, resolveManifestPath } from "./load.js";
+/** Root directories scanned by default. */ export const DEFAULT_ROOTS = [
+    'src',
+    'app'
+];
+/** File extensions scanned by default — the JSX-bearing source formats. */ export const DEFAULT_EXTENSIONS = [
+    'tsx',
+    'jsx',
+    'ts',
+    'js',
+    'mdx'
+];
+/** Directory names never descended into. */ export const DEFAULT_IGNORE = [
+    'node_modules',
+    '.next',
+    '.git',
+    'dist',
+    'build',
+    'coverage',
+    '.turbo'
+];
+const toPosix = (p)=>p.split(sep).join('/');
+/** Recursively collects scannable file paths under `dir`. */ const walk = (dir, exts, ignore, out)=>{
+    let entries;
+    try {
+        entries = readdirSync(dir, {
+            withFileTypes: true
+        });
+    } catch  {
+        return; // unreadable/non-existent root — skip silently, the caller reports totals
+    }
+    for (const entry of entries){
+        const full = join(dir, entry.name);
+        if (entry.isDirectory()) {
+            if (!ignore.has(entry.name)) walk(full, exts, ignore, out);
+        } else if (entry.isFile()) {
+            const dot = entry.name.lastIndexOf('.');
+            if (dot !== -1 && exts.has(entry.name.slice(dot + 1))) out.push(full);
+        }
+    }
+};
+/**
+ * Scans the project for literal icon usages and builds a manifest. Pure with
+ * respect to output (writes nothing) — use {@link writeIconUsageManifest} to
+ * persist the result.
+ *
+ * @example
+ * ```ts
+ * const { manifest } = scanIconUsages({ roots: ['src', 'app'] })
+ * console.log(manifest.names) // ['arrow-right', 'chevron', 'x', …]
+ * ```
+ */ export const scanIconUsages = (options = {})=>{
+    const cwd = options.cwd ?? process.cwd();
+    const roots = options.roots?.length ? options.roots : DEFAULT_ROOTS;
+    const exts = new Set((options.extensions?.length ? options.extensions : DEFAULT_EXTENSIONS).map((e)=>e.replace(/^\./, '')));
+    const ignore = new Set(options.ignore?.length ? options.ignore : DEFAULT_IGNORE);
+    const files = [];
+    let rootsScanned = 0;
+    for (const root of roots){
+        const abs = isAbsolute(root) ? root : resolve(cwd, root);
+        let stat = null;
+        try {
+            stat = statSync(abs);
+        } catch  {
+            continue; // missing root — skip; the caller checks `rootsScanned`
+        }
+        rootsScanned++;
+        if (stat.isDirectory()) walk(abs, exts, ignore, files);
+        else if (stat.isFile()) files.push(abs);
+    }
+    const usages = [];
+    let filesScanned = 0;
+    for (const file of files){
+        let source;
+        try {
+            source = readFileSync(file, 'utf8');
+        } catch  {
+            continue;
+        }
+        filesScanned++;
+        const rel = toPosix(relative(cwd, file));
+        for (const u of extractIconUsages(source, {
+            components: options.components
+        })){
+            usages.push({
+                name: u.name,
+                file: rel,
+                line: u.line,
+                column: u.column
+            });
+        }
+    }
+    // Deterministic ordering so the manifest is diff-stable across runs.
+    usages.sort((a, b)=>a.name.localeCompare(b.name) || a.file.localeCompare(b.file) || a.line - b.line || a.column - b.column);
+    const names = [
+        ...new Set(usages.map((u)=>u.name))
+    ].sort((a, b)=>a.localeCompare(b));
+    return {
+        manifest: {
+            version: 1,
+            generatedAt: new Date().toISOString(),
+            names,
+            usages
+        },
+        filesScanned,
+        rootsScanned
+    };
+};
+/**
+ * Writes a manifest to disk as pretty-printed JSON (trailing newline). Returns
+ * the absolute path written.
+ */ export const writeIconUsageManifest = (manifest, path)=>{
+    const abs = isAbsolute(path) ? path : resolve(process.cwd(), path);
+    writeFileSync(abs, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    return abs;
+};
+
+//# sourceMappingURL=index.js.map

package/dist/scan/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/scan/index.ts"],"sourcesContent":["/**\n * Build-time icon-usage scan — the Node-side entry point. Walks a project's\n * source tree, extracts every literal `<Icon name=\"…\">` (see {@link extractIconUsages}),\n * and aggregates the result into an {@link IconUsageManifest} that the admin\n * \"requested icons\" panel reads.\n *\n * Zero third-party dependencies: directory walking uses `node:fs` directly so\n * the package adds nothing to a consumer's install for this feature.\n */\n\nimport { type Dirent, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'\nimport { isAbsolute, join, relative, resolve, sep } from 'node:path'\n\nimport { extractIconUsages } from './extract.js'\nimport type { IconUsage, IconUsageManifest } from './types.js'\n\nexport { extractIconUsages } from './extract.js'\nexport type { ExtractedUsage, ExtractOptions } from './extract.js'\nexport type { IconUsage, IconUsageManifest } from './types.js'\n// Manifest path resolution + reading live in ./load (a bundler-safe leaf with no\n// runtime relative imports) so the admin panel can import them without pulling\n// in this CLI/parser module. Re-exported here to keep the `./scan` API in one place.\nexport { DEFAULT_MANIFEST_FILENAME, loadIconUsageManifest, MANIFEST_PATH_ENV, resolveManifestPath } from './load.js'\n\n/** Root directories scanned by default. */\nexport const DEFAULT_ROOTS = ['src', 'app']\n\n/** File extensions scanned by default — the JSX-bearing source formats. */\nexport const DEFAULT_EXTENSIONS = ['tsx', 'jsx', 'ts', 'js', 'mdx']\n\n/** Directory names never descended into. */\nexport const DEFAULT_IGNORE = ['node_modules', '.next', '.git', 'dist', 'build', 'coverage', '.turbo']\n\nexport interface ScanOptions {\n  /**\n   * Directories (or individual files) to scan, relative to {@link cwd} or\n   * absolute. Each directory is walked recursively.\n   *\n   * @default ['src', 'app']\n   */\n  roots?: string[]\n  /**\n   * Working directory the scan resolves {@link roots} and reports file paths\n   * relative to.\n   *\n   * @default process.cwd()\n   */\n  cwd?: string\n  /**\n   * JSX tag names treated as icon usages. Forwarded to {@link extractIconUsages}.\n   *\n   * @default ['Icon']\n   */\n  components?: string[]\n  /**\n   * File extensions (without the dot) to read.\n   *\n   * @default ['tsx', 'jsx', 'ts', 'js', 'mdx']\n   */\n  extensions?: string[]\n  /**\n   * Directory names to skip while walking.\n   *\n   * @default ['node_modules', '.next', '.git', 'dist', 'build', 'coverage', '.turbo']\n   */\n  ignore?: string[]\n}\n\nconst toPosix = (p: string): string => p.split(sep).join('/')\n\n/** Recursively collects scannable file paths under `dir`. */\nconst walk = (dir: string, exts: Set<string>, ignore: Set<string>, out: string[]): void => {\n  let entries: Dirent[]\n  try {\n    entries = readdirSync(dir, { withFileTypes: true })\n  } catch {\n    return // unreadable/non-existent root — skip silently, the caller reports totals\n  }\n  for (const entry of entries) {\n    const full = join(dir, entry.name)\n    if (entry.isDirectory()) {\n      if (!ignore.has(entry.name)) walk(full, exts, ignore, out)\n    } else if (entry.isFile()) {\n      const dot = entry.name.lastIndexOf('.')\n      if (dot !== -1 && exts.has(entry.name.slice(dot + 1))) out.push(full)\n    }\n  }\n}\n\n/** The result of a {@link scanIconUsages} run. */\nexport interface ScanResult {\n  /** The assembled manifest, ready to write. */\n  manifest: IconUsageManifest\n  /** Number of files read during the scan. */\n  filesScanned: number\n  /** Number of scan roots that actually existed — `0` means every root was missing (wrong cwd?). */\n  rootsScanned: number\n}\n\n/**\n * Scans the project for literal icon usages and builds a manifest. Pure with\n * respect to output (writes nothing) — use {@link writeIconUsageManifest} to\n * persist the result.\n *\n * @example\n * ```ts\n * const { manifest } = scanIconUsages({ roots: ['src', 'app'] })\n * console.log(manifest.names) // ['arrow-right', 'chevron', 'x', …]\n * ```\n */\nexport const scanIconUsages = (options: ScanOptions = {}): ScanResult => {\n  const cwd = options.cwd ?? process.cwd()\n  const roots = options.roots?.length ? options.roots : DEFAULT_ROOTS\n  const exts = new Set((options.extensions?.length ? options.extensions : DEFAULT_EXTENSIONS).map((e) => e.replace(/^\\./, '')))\n  const ignore = new Set(options.ignore?.length ? options.ignore : DEFAULT_IGNORE)\n\n  const files: string[] = []\n  let rootsScanned = 0\n  for (const root of roots) {\n    const abs = isAbsolute(root) ? root : resolve(cwd, root)\n    let stat: ReturnType<typeof statSync> | null = null\n    try {\n      stat = statSync(abs)\n    } catch {\n      continue // missing root — skip; the caller checks `rootsScanned`\n    }\n    rootsScanned++\n    if (stat.isDirectory()) walk(abs, exts, ignore, files)\n    else if (stat.isFile()) files.push(abs)\n  }\n\n  const usages: IconUsage[] = []\n  let filesScanned = 0\n  for (const file of files) {\n    let source: string\n    try {\n      source = readFileSync(file, 'utf8')\n    } catch {\n      continue\n    }\n    filesScanned++\n    const rel = toPosix(relative(cwd, file))\n    for (const u of extractIconUsages(source, { components: options.components })) {\n      usages.push({ name: u.name, file: rel, line: u.line, column: u.column })\n    }\n  }\n\n  // Deterministic ordering so the manifest is diff-stable across runs.\n  usages.sort((a, b) => a.name.localeCompare(b.name) || a.file.localeCompare(b.file) || a.line - b.line || a.column - b.column)\n  const names = [...new Set(usages.map((u) => u.name))].sort((a, b) => a.localeCompare(b))\n\n  return {\n    manifest: { version: 1, generatedAt: new Date().toISOString(), names, usages },\n    filesScanned,\n    rootsScanned,\n  }\n}\n\n/**\n * Writes a manifest to disk as pretty-printed JSON (trailing newline). Returns\n * the absolute path written.\n */\nexport const writeIconUsageManifest = (manifest: IconUsageManifest, path: string): string => {\n  const abs = isAbsolute(path) ? path : resolve(process.cwd(), path)\n  writeFileSync(abs, `${JSON.stringify(manifest, null, 2)}\\n`, 'utf8')\n  return abs\n}\n"],"names":["readdirSync","readFileSync","statSync","writeFileSync","isAbsolute","join","relative","resolve","sep","extractIconUsages","DEFAULT_MANIFEST_FILENAME","loadIconUsageManifest","MANIFEST_PATH_ENV","resolveManifestPath","DEFAULT_ROOTS","DEFAULT_EXTENSIONS","DEFAULT_IGNORE","toPosix","p","split","walk","dir","exts","ignore","out","entries","withFileTypes","entry","full","name","isDirectory","has","isFile","dot","lastIndexOf","slice","push","scanIconUsages","options","cwd","process","roots","length","Set","extensions","map","e","replace","files","rootsScanned","root","abs","stat","usages","filesScanned","file","source","rel","u","components","line","column","sort","a","b","localeCompare","names","manifest","version","generatedAt","Date","toISOString","writeIconUsageManifest","path","JSON","stringify"],"mappings":"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"}

package/dist/scan/live.d.ts

@@ -0,0 +1,20 @@
+import type { IconUsageManifest } from './types';
+export interface LiveScanOptions {
+    /** Directories/files to scan, relative to {@link cwd} or absolute. @default ['src', 'app'] */
+    roots?: string[];
+    /** Working directory. @default process.cwd() */
+    cwd?: string;
+    /** JSX tag names treated as icon usages. @default ['Icon'] */
+    components?: string[];
+    /** File extensions (without the dot) to read. @default ['tsx', 'jsx', 'ts', 'js', 'mdx'] */
+    extensions?: string[];
+    /** Directory names to skip. @default ['node_modules', '.next', '.git', 'dist', 'build', 'coverage', '.turbo'] */
+    ignore?: string[];
+}
+/**
+ * Scan the source tree and return a manifest — the same shape the CLI writes,
+ * built in memory. Returns an empty manifest (no throw) when the roots don't
+ * exist, so it's safe to call at admin-render time.
+ */
+export declare const scanIconUsagesLive: (options?: LiveScanOptions) => IconUsageManifest;
+//# sourceMappingURL=live.d.ts.map

package/dist/scan/live.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"live.d.ts","sourceRoot":"","sources":["../../src/scan/live.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAa,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAmB3D,MAAM,WAAW,eAAe;IAC9B,8FAA8F;IAC9F,KAAK,CAAC,EAAE,MAAM,EAAE,CAAA;IAChB,gDAAgD;IAChD,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,8DAA8D;IAC9D,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;IACrB,4FAA4F;IAC5F,UAAU,CAAC,EAAE,MAAM,EAAE,CAAA;IACrB,iHAAiH;IACjH,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;CAClB;AAuBD;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,GAAI,UAAS,eAAoB,KAAG,iBAqClE,CAAA"}