@typecad/cuttlefish 1.0.0-alpha.13 → 1.0.0-alpha.15

package/dist/libdef/component-discovery.js

@@ -1,83 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-/** Walk a directory recursively, returning all .h files. */
-function walkHeaders(dir) {
-    if (!existsSync(dir))
-        return [];
-    const out = [];
-    const stack = [dir];
-    while (stack.length > 0) {
-        const cur = stack.pop();
-        let entries;
-        try {
-            entries = readdirSync(cur);
-        }
-        catch {
-            continue;
-        }
-        for (const name of entries) {
-            const full = join(cur, name);
-            try {
-                const st = statSync(full);
-                if (st.isDirectory()) {
-                    stack.push(full);
-                }
-                else if (name.toLowerCase().endsWith('.h')) {
-                    out.push(full);
-                }
-            }
-            catch {
-                // Stat failed (race); skip.
-            }
-        }
-    }
-    return out;
-}
-/**
- * Find all .h files for the declared components.
- *
- * - managed: scan `managed_components/<name>/include/` (falling back to the
- *   component dir if no include/ exists). Populated by `idf.py reconfigure`.
- * - local: scan `<path>/include/` (or `<path>/`).
- * - builtin: scan `<idfRoot>/components/<name>/include/` (IDF ships with these).
- *
- * For builtins the output .d.ts goes to `<projectDir>/.cuttlefish/component-decls/<component>/`
- * — never into `$IDF_PATH/components/`, which would pollute the IDF install.
- *
- * Returned entries are unsorted — the caller decides ordering.
- */
-export function discoverComponentHeaders(projectDir, roots) {
-    const headers = [];
-    for (const name of roots.managed) {
-        const base = join(projectDir, 'managed_components', name);
-        const includeDir = join(base, 'include');
-        const dir = existsSync(includeDir) ? includeDir : base;
-        for (const h of walkHeaders(dir)) {
-            headers.push({ path: h, outputDir: dir });
-        }
-    }
-    for (const localPath of roots.local) {
-        const includeDir = join(localPath, 'include');
-        const dir = existsSync(includeDir) ? includeDir : localPath;
-        for (const h of walkHeaders(dir)) {
-            headers.push({ path: h, outputDir: dir });
-        }
-    }
-    if (roots.idfRoot) {
-        for (const name of roots.builtin) {
-            const base = join(roots.idfRoot, 'components', name);
-            const includeDir = join(base, 'include');
-            const dir = existsSync(includeDir) ? includeDir : base;
-            // Project-local cache for builtins. Mirrors the include/ layout so
-            // imports can substitute `managed_components/<name>/include/X.d.ts`
-            // patterns. Each header's .d.ts is named after the header basename.
-            const outDir = join(projectDir, '.cuttlefish', 'component-decls', name);
-            if (!existsSync(outDir))
-                mkdirSync(outDir, { recursive: true });
-            for (const h of walkHeaders(dir)) {
-                headers.push({ path: h, outputDir: outDir });
-            }
-        }
-    }
-    return headers;
-}

package/dist/theme-tokens.d.ts

@@ -1,22 +0,0 @@
-/** One declaration (`--token: value`), order-preserving. */
-type Decl = [name: string, value: string];
-export interface ShadcnTheme {
-    name: string;
-    light: Decl[];
-    dark: Decl[];
-}
-/** Where a project keeps its own themes: src/styles/themes/*.css next to
- *  the kit stylesheet. Project themes win over same-named package ones —
- *  pasting a theme is dropping a file into YOUR project, never node_modules. */
-export declare function projectThemesDir(projectRoot: string): string;
-/** Theme names, project-local (src/styles/themes/) first, then the ones
- *  shipped in the package (assets/shadcn/themes/). */
-export declare function listShadcnThemes(projectRoot?: string): string[];
-/** Load a theme by name — project-local directory first, then the package
- *  included set. Throws with the available names when missing. */
-export declare function loadShadcnTheme(name: string, projectRoot?: string): ShadcnTheme;
-/** Merge a theme's tokens into a kit stylesheet's :root/.dark blocks and
- *  return the rewritten text. Throws when a merged block is missing any
- *  token the kit's recipes reference. */
-export declare function applyShadcnTheme(cssText: string, theme: ShadcnTheme): string;
-export {};

package/dist/theme-tokens.js

@@ -1,172 +0,0 @@
-// ---------------------------------------------------------------------------
-// shadcn kit themes — the included token sets under assets/shadcn/themes/.
-//
-// A theme file is two CSS blocks (:root = light tokens, .dark = dark tokens)
-// plus an optional header comment. Selecting a theme MERGES each block into
-// the kit's stylesheet: declarations the theme defines override the kit's,
-// and kit-specific extras the theme lacks (notably --destructive-background,
-// which stock shadcn themes don't carry) keep their current values — so any
-// stock theme from ui.shadcn.com or tweakcn pastes cleanly.
-//
-// Used by `cuttlefish add shadcn --theme <name>` (scaffold time) and
-// `cuttlefish theme <name>` (swap an existing project's kit stylesheet).
-// ---------------------------------------------------------------------------
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-const THEMES_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../assets/shadcn/themes");
-/** The tokens the kit's recipes reference; every merged theme must cover them. */
-const REQUIRED_TOKENS = [
-    "--background", "--foreground",
-    "--card", "--card-foreground",
-    "--primary", "--primary-foreground",
-    "--secondary", "--secondary-foreground",
-    "--muted", "--muted-foreground",
-    "--accent", "--accent-foreground",
-    "--destructive", "--destructive-foreground", "--destructive-background",
-    "--border", "--input", "--radius",
-];
-/** Blank out /* … *​/ comment interiors (same length) so selector searches
- *  can't match inside a comment while byte offsets stay valid against the
- *  original text. The kit's header comment literally contains `.dark { ... }`
- *  as documentation — an unmasked search spliced tokens into the comment and
- *  left the real block untouched. */
-function maskComments(css) {
-    return css.replace(/\/\*[\s\S]*?\*\//g, (m) => " ".repeat(m.length));
-}
-/** Locate `selector {` in css, skipping comment spans. Custom-property values
- *  contain no braces, so the block ends at the first `}` after the opening
- *  one. */
-function blockRange(css, selector) {
-    const escaped = selector.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const m = new RegExp(escaped + "\\s*\\{").exec(maskComments(css));
-    if (!m)
-        return null;
-    const open = m.index + m[0].length;
-    const close = css.indexOf("}", open);
-    if (close < 0)
-        return null;
-    return { selStart: m.index, open, close };
-}
-/** Parse a token block's declarations (line-oriented; one decl per line, the
- *  format both the kit and stock shadcn themes use). */
-function parseDecls(block) {
-    const out = [];
-    for (const line of block.split("\n")) {
-        const m = /^\s*(--[\w-]+)\s*:\s*([^;]+);/.exec(line);
-        if (m)
-            out.push([m[1], m[2].trim()]);
-    }
-    return out;
-}
-function emitBlock(selector, decls) {
-    const body = decls.map(([k, v]) => `  ${k}: ${v};`).join("\n");
-    return `${selector} {\n${body}\n}`;
-}
-/** Order-preserving override merge: base order, overrides in place, theme-only
- *  declarations appended. */
-function mergeDecls(base, override) {
-    const out = base.map(([k, v]) => [k, v]);
-    const indexByName = new Map(out.map(([k], i) => [k, i]));
-    for (const [k, v] of override) {
-        const existing = indexByName.get(k);
-        if (existing !== undefined)
-            out[existing][1] = v;
-        else {
-            indexByName.set(k, out.length);
-            out.push([k, v]);
-        }
-    }
-    return out;
-}
-/** Where a project keeps its own themes: src/styles/themes/*.css next to
- *  the kit stylesheet. Project themes win over same-named package ones —
- *  pasting a theme is dropping a file into YOUR project, never node_modules. */
-export function projectThemesDir(projectRoot) {
-    return path.resolve(projectRoot, "src/styles/themes");
-}
-function themeNamesIn(dir) {
-    if (!fs.existsSync(dir))
-        return [];
-    return fs.readdirSync(dir)
-        .filter((f) => f.endsWith(".css") && !f.startsWith("_"))
-        .map((f) => f.replace(/\.css$/, ""))
-        .sort();
-}
-/** Theme names, project-local (src/styles/themes/) first, then the ones
- *  shipped in the package (assets/shadcn/themes/). */
-export function listShadcnThemes(projectRoot) {
-    const local = projectRoot ? themeNamesIn(projectThemesDir(projectRoot)) : [];
-    const included = themeNamesIn(THEMES_DIR);
-    return [...new Set([...local, ...included])].sort();
-}
-function formatThemeList(projectRoot) {
-    const local = projectRoot ? themeNamesIn(projectThemesDir(projectRoot)) : [];
-    const included = themeNamesIn(THEMES_DIR);
-    const lines = [];
-    if (local.length > 0) {
-        lines.push("project (src/styles/themes/):");
-        for (const n of local)
-            lines.push(`  ${n}`);
-    }
-    lines.push("included with cuttlefish:");
-    for (const n of included)
-        lines.push(`  ${n}`);
-    lines.push("(paste your own: src/styles/themes/<name>.css in this project)");
-    return lines.join("\n");
-}
-/** Load a theme by name — project-local directory first, then the package
- *  included set. Throws with the available names when missing. */
-export function loadShadcnTheme(name, projectRoot) {
-    if (!/^[a-z0-9-]+$/.test(name)) {
-        throw new Error(`Invalid theme name "${name}" — use letters, digits, and dashes.`);
-    }
-    const candidates = projectRoot
-        ? [path.join(projectThemesDir(projectRoot), `${name}.css`), path.join(THEMES_DIR, `${name}.css`)]
-        : [path.join(THEMES_DIR, `${name}.css`)];
-    const file = candidates.find((c) => fs.existsSync(c));
-    if (!file) {
-        throw new Error(`Unknown theme "${name}". Available themes:\n${formatThemeList(projectRoot)}`);
-    }
-    const text = fs.readFileSync(file, "utf-8");
-    const rootRange = blockRange(text, ":root");
-    const darkRange = blockRange(text, ".dark");
-    if (!rootRange || !darkRange) {
-        throw new Error(`Theme "${name}" must define both a :root and a .dark token block.`);
-    }
-    const light = parseDecls(text.slice(rootRange.open, rootRange.close));
-    const dark = parseDecls(text.slice(darkRange.open, darkRange.close));
-    if (light.length === 0 || dark.length === 0) {
-        throw new Error(`Theme "${name}" has empty token blocks — paste the theme's :root and .dark declarations.`);
-    }
-    return { name, light, dark };
-}
-/** Merge a theme's tokens into a kit stylesheet's :root/.dark blocks and
- *  return the rewritten text. Throws when a merged block is missing any
- *  token the kit's recipes reference. */
-export function applyShadcnTheme(cssText, theme) {
-    let out = cssText;
-    for (const [selector, themeDecls] of [[".dark", theme.dark], [":root", theme.light]]) {
-        const range = blockRange(out, selector);
-        if (!range) {
-            throw new Error(`The kit stylesheet has no ${selector} token block to replace.`);
-        }
-        const merged = mergeDecls(parseDecls(out.slice(range.open, range.close)), themeDecls);
-        out = out.slice(0, range.selStart) + emitBlock(selector, merged) + out.slice(range.close + 1);
-    }
-    // Validate AFTER both merges (a token can live in either block).
-    const rootRange = blockRange(out, ":root");
-    const darkRange = blockRange(out, ".dark");
-    const names = new Set();
-    if (rootRange)
-        for (const [k] of parseDecls(out.slice(rootRange.open, rootRange.close)))
-            names.add(k);
-    if (darkRange)
-        for (const [k] of parseDecls(out.slice(darkRange.open, darkRange.close)))
-            names.add(k);
-    const missing = REQUIRED_TOKENS.filter((t) => !names.has(t));
-    if (missing.length > 0) {
-        throw new Error(`Theme "${theme.name}" leaves required tokens unset: ${missing.join(", ")}`);
-    }
-    return out;
-}