@nuee/cli 0.4.1 → 0.5.0

package/dist/add.d.ts

@@ -1,7 +1,7 @@
-export type AddOptions = {
-    defaults?: boolean;
-    "dry-run"?: boolean;
+export { getMissingDependencies } from "./dependencies.js";
+import type { CliOptions } from "./arguments.js";
+export type AddOptions = CliOptions & {
+    /** @deprecated Use skip-dependencies. */
     skipDependencyInstall?: boolean;
-    "skip-dependencies"?: boolean;
-} & Record<string, boolean | string | undefined>;
+};
 export declare function add(projectDirectory: string, componentNames: string | readonly string[], options?: AddOptions): Promise<void>;

package/dist/add.js

@@ -1,10 +1,12 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, relative, resolve } from "node:path";
+import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
-import { defaultConfig, hasConfig, readConfig, resolveConfigAlias } from "./config.js";
-import { installDependencies } from "./dependencies.js";
-import { init } from "./init.js";
+import { defaultConfig, getDefaultAliases, hasConfig, readConfig, resolveConfigAlias, } from "./config.js";
+export { getMissingDependencies } from "./dependencies.js";
+import { getMissingDependencies, installDependencies } from "./dependencies.js";
+import { applyInitialization, prepareInitialization } from "./init.js";
 import { resolveComponent } from "./registry.js";
+import { parseSource, removeReducedMotionStyles } from "./source.js";
 function isNotFoundError(error) {
     return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
@@ -23,13 +25,11 @@ async function askYesNo(question, defaultValue) {
         readline.close();
     }
 }
-async function writeSource(source, targetPath, confirmOverwrite) {
+async function writeSource(source, targetPath) {
     try {
         const currentSource = await readFile(targetPath, "utf8");
         if (currentSource === source)
-            return "unchanged";
-        if (!(await confirmOverwrite()))
-            throw new Error("Component installation canceled.");
+            return;
     }
     catch (error) {
         if (!isNotFoundError(error))
@@ -37,7 +37,6 @@ async function writeSource(source, targetPath, confirmOverwrite) {
     }
     await mkdir(dirname(targetPath), { recursive: true });
     await writeFile(targetPath, source, "utf8");
-    return "written";
 }
 function resolveTargetPath(uiDirectory, filePath) {
     if (isAbsolute(filePath))
@@ -52,35 +51,6 @@ function resolveTargetPath(uiDirectory, filePath) {
 function replaceTokenImport(source, stylesAlias) {
     return source.replaceAll("@nuee/tokens/semantic.stylex", `${stylesAlias}/semantic.stylex`);
 }
-function removeReducedMotionStyles(source) {
-    const mediaQuery = '"@media (prefers-reduced-motion: reduce)":';
-    let transformedSource = source;
-    let mediaQueryIndex = transformedSource.indexOf(mediaQuery);
-    while (mediaQueryIndex !== -1) {
-        const propertyStart = transformedSource.lastIndexOf("\n", mediaQueryIndex) + 1;
-        const openingBraceIndex = transformedSource.indexOf("{", mediaQueryIndex + mediaQuery.length);
-        let depth = 0;
-        let propertyEnd = openingBraceIndex;
-        for (let index = openingBraceIndex; index < transformedSource.length; index += 1) {
-            if (transformedSource[index] === "{")
-                depth += 1;
-            if (transformedSource[index] === "}")
-                depth -= 1;
-            if (depth !== 0)
-                continue;
-            propertyEnd = index + 1;
-            if (transformedSource[propertyEnd] === ",")
-                propertyEnd += 1;
-            if (transformedSource[propertyEnd] === "\n")
-                propertyEnd += 1;
-            break;
-        }
-        transformedSource =
-            transformedSource.slice(0, propertyStart) + transformedSource.slice(propertyEnd);
-        mediaQueryIndex = transformedSource.indexOf(mediaQuery);
-    }
-    return transformedSource;
-}
 export async function add(projectDirectory, componentNames, options = {}) {
     const componentNameList = [
         ...new Set(typeof componentNames === "string" ? [componentNames] : componentNames),
@@ -89,43 +59,75 @@ export async function add(projectDirectory, componentNames, options = {}) {
         throw new Error("Enter at least one component name to add.");
     }
     const shouldInitialize = !(await hasConfig(projectDirectory));
-    if (shouldInitialize && !options["dry-run"]) {
-        await init(projectDirectory, {
-            ...options,
-            "skip-dependencies": options.skipDependencyInstall || options["skip-dependencies"],
-        }, false);
+    let config;
+    if (shouldInitialize) {
+        const defaultAliases = await getDefaultAliases(projectDirectory);
+        config = {
+            ...defaultConfig,
+            aliases: {
+                ui: options.ui ?? defaultAliases.ui,
+                styles: options.styles ?? options.tokens ?? defaultAliases.styles,
+            },
+        };
+    }
+    else {
+        config = await readConfig(projectDirectory);
     }
-    const config = options["dry-run"] && shouldInitialize ? defaultConfig : await readConfig(projectDirectory);
     const resolvedList = await Promise.all(componentNameList.map(resolveComponent));
+    await resolveConfigAlias(projectDirectory, config.aliases.styles, "aliases.styles");
     const uiDirectory = await resolveConfigAlias(projectDirectory, config.aliases.ui, "aliases.ui");
-    let isOverwriteConfirmed = false;
-    async function confirmOverwrite() {
-        if (isOverwriteConfirmed)
-            return true;
-        isOverwriteConfirmed = await askYesNo("Files with the same names already exist. Overwrite all?", false);
-        return isOverwriteConfirmed;
-    }
+    const sources = [];
     for (const resolved of resolvedList) {
         for (const file of resolved.files) {
-            const targetPath = resolveTargetPath(uiDirectory, file.path);
-            if (options["dry-run"])
-                continue;
-            await writeSource(config.accessibility.respectReducedMotion
-                ? replaceTokenImport(file.content, config.aliases.styles)
-                : removeReducedMotionStyles(replaceTokenImport(file.content, config.aliases.styles)), targetPath, confirmOverwrite);
+            const isScript = /\.[cm]?[jt]sx?$/.test(file.path);
+            let source = replaceTokenImport(file.content, config.aliases.styles);
+            if (isScript && !config.accessibility.respectReducedMotion) {
+                source = removeReducedMotionStyles(source);
+            }
+            if (isScript)
+                parseSource(source);
+            sources.push({ source, targetPath: resolveTargetPath(uiDirectory, file.path) });
         }
     }
-    const externalDependencySet = new Set();
-    for (const resolved of resolvedList) {
-        for (const dependency of resolved.externalDependencies)
-            externalDependencySet.add(dependency);
+    const externalDependencies = await getMissingDependencies(projectDirectory, [
+        ...new Set(resolvedList.flatMap((resolved) => resolved.externalDependencies)),
+    ]);
+    const skipDependencies = options.skipDependencyInstall || options["skip-dependencies"];
+    const initialization = shouldInitialize
+        ? await prepareInitialization(projectDirectory, {
+            ...options,
+            defaults: true,
+            ui: config.aliases.ui,
+            styles: config.aliases.styles,
+            "skip-dependencies": skipDependencies,
+        })
+        : undefined;
+    const overwriteFileNames = [];
+    for (const { source, targetPath } of sources) {
+        try {
+            if ((await readFile(targetPath, "utf8")) !== source)
+                overwriteFileNames.push(basename(targetPath));
+        }
+        catch (error) {
+            if (!isNotFoundError(error))
+                throw error;
+        }
+    }
+    if (overwriteFileNames.length > 0 && !options["dry-run"]) {
+        const fileLabel = overwriteFileNames.join(", ");
+        const shouldOverwrite = await askYesNo(`Overwrite ${overwriteFileNames.length} existing file${overwriteFileNames.length === 1 ? "" : "s"} (${fileLabel})?`, false);
+        if (!shouldOverwrite)
+            throw new Error("Component installation canceled.");
+    }
+    if (initialization && !options["dry-run"]) {
+        await applyInitialization(projectDirectory, initialization);
+    }
+    for (const { source, targetPath } of sources) {
+        if (options["dry-run"])
+            continue;
+        await writeSource(source, targetPath);
     }
-    const externalDependencies = [...externalDependencySet];
-    const shouldInstallDependencies = externalDependencies.length > 0 &&
-        !options.skipDependencyInstall &&
-        !options["skip-dependencies"] &&
-        !options["dry-run"] &&
-        (await askYesNo(`Install external dependencies (${externalDependencies.join(", ")})?`, true));
+    const shouldInstallDependencies = externalDependencies.length > 0 && !skipDependencies && !options["dry-run"];
     if (shouldInstallDependencies) {
         await installDependencies(projectDirectory, externalDependencies);
     }

package/dist/arguments.d.ts

@@ -1,16 +1,26 @@
-export type CliOptions = Record<string, boolean | string | undefined> & {
+export type CliOptions = {
     cwd?: string;
     defaults?: boolean;
-    framework?: string;
     "dry-run"?: boolean;
     force?: boolean;
     "skip-dependencies"?: boolean;
     styles?: string;
     tokens?: string;
     ui?: string;
+    vite?: boolean;
 };
 export declare function parseArguments(arguments_: readonly string[]): {
     command: string;
-    options: CliOptions;
+    options: {
+        cwd?: string | undefined;
+        defaults?: boolean | undefined;
+        "dry-run"?: boolean | undefined;
+        force?: boolean | undefined;
+        "skip-dependencies"?: boolean | undefined;
+        styles?: string | undefined;
+        tokens?: string | undefined;
+        ui?: string | undefined;
+        vite?: boolean | undefined;
+    };
     positionals: string[];
 };

package/dist/arguments.js

@@ -1,21 +1,20 @@
+import { parseArgs } from "node:util";
 export function parseArguments(arguments_) {
-    const [command, ...rest] = arguments_;
-    const options = {};
-    const positionals = [];
-    for (let index = 0; index < rest.length; index += 1) {
-        const argument = rest[index];
-        if (!argument.startsWith("--")) {
-            positionals.push(argument);
-            continue;
-        }
-        const name = argument.slice(2);
-        const nextArgument = rest[index + 1];
-        if (!nextArgument || nextArgument.startsWith("--")) {
-            options[name] = true;
-            continue;
-        }
-        options[name] = nextArgument;
-        index += 1;
-    }
+    const [command, ...args] = arguments_;
+    const { values: options, positionals } = parseArgs({
+        args,
+        allowPositionals: true,
+        options: {
+            cwd: { type: "string" },
+            defaults: { type: "boolean" },
+            "dry-run": { type: "boolean" },
+            force: { type: "boolean" },
+            "skip-dependencies": { type: "boolean" },
+            styles: { type: "string" },
+            tokens: { type: "string" },
+            ui: { type: "string" },
+            vite: { type: "boolean" },
+        },
+    });
     return { command, options, positionals };
 }

package/dist/config.d.ts

@@ -14,4 +14,8 @@ export declare function validateConfig(config: unknown): NueeConfig;
 export declare function readConfig(projectDirectory: string): Promise<NueeConfig>;
 export declare function writeConfig(projectDirectory: string, config: NueeConfig): Promise<string>;
 export declare function resolveConfigPath(projectDirectory: string, path: string, name: string): string;
+export declare function getDefaultAliases(projectDirectory: string): Promise<{
+    ui: string;
+    styles: string;
+}>;
 export declare function resolveConfigAlias(projectDirectory: string, alias: string, name: string): Promise<string>;

package/dist/config.js

@@ -1,5 +1,6 @@
 import { access, readFile, writeFile } from "node:fs/promises";
 import { isAbsolute, join, relative, resolve } from "node:path";
+import { createPathsMatcher, parseTsconfig } from "get-tsconfig";
 import { parse } from "jsonc-parser";
 export const configFileName = "nuee.json";
 export const defaultConfig = {
@@ -11,12 +12,26 @@ export const defaultConfig = {
         styles: "@/styles",
     },
 };
+function getAliasPrefix(paths) {
+    if (!paths)
+        return undefined;
+    for (const [pattern, targetList] of Object.entries(paths)) {
+        if (!pattern.endsWith("*"))
+            continue;
+        const hasProjectRootTarget = targetList.some((target) => ["*", "./*", "src/*", "./src/*"].includes(target.replaceAll("\\", "/")));
+        if (hasProjectRootTarget)
+            return pattern.slice(0, -1);
+    }
+    return undefined;
+}
 export async function hasConfig(projectDirectory) {
     try {
         await access(resolve(projectDirectory, configFileName));
         return true;
     }
-    catch {
+    catch (error) {
+        if (!isNotFoundError(error))
+            throw error;
         return false;
     }
 }
@@ -28,6 +43,9 @@ function ensureRelativePath(projectDirectory, path, name) {
     }
 }
 export function validateConfig(config) {
+    if (typeof config !== "object" || config === null || Array.isArray(config)) {
+        throw new Error("Configure nuee.json as an object.");
+    }
     const candidate = config;
     if (candidate.paths || candidate.tokens) {
         throw new Error("This nuee.json uses an older format. Run `nuee init --force` to create alias-based configuration.");
@@ -43,7 +61,8 @@ export function validateConfig(config) {
         throw new Error("Configure aliases.styles.");
     }
     if (candidate.accessibility !== undefined &&
-        (typeof candidate.accessibility !== "object" ||
+        (candidate.accessibility === null ||
+            typeof candidate.accessibility !== "object" ||
             typeof candidate.accessibility.respectReducedMotion !== "boolean")) {
         throw new Error("Configure accessibility.respectReducedMotion as a boolean.");
     }
@@ -88,44 +107,51 @@ export function resolveConfigPath(projectDirectory, path, name) {
 }
 async function readTsConfig(projectDirectory) {
     for (const fileName of ["tsconfig.json", "jsconfig.json"]) {
+        const path = resolve(projectDirectory, fileName);
         try {
-            return parse(await readFile(resolve(projectDirectory, fileName), "utf8"));
+            const source = await readFile(path, "utf8");
+            const errors = [];
+            const value = parse(source, errors, { allowTrailingComma: true });
+            if (errors.length || !value || typeof value !== "object" || Array.isArray(value)) {
+                throw new Error(`Invalid configuration: ${fileName}`);
+            }
+            return { path, config: parseTsconfig(path) };
         }
         catch (error) {
-            if (!isNotFoundError(error)) {
-                continue;
-            }
+            if (!isNotFoundError(error))
+                throw error;
         }
     }
     return undefined;
 }
-function resolvePathAlias(alias, paths) {
-    for (const [pattern, targets] of Object.entries(paths)) {
-        const wildcardIndex = pattern.indexOf("*");
-        if (wildcardIndex === -1) {
-            if (pattern === alias)
-                return targets[0];
-            continue;
-        }
-        const prefix = pattern.slice(0, wildcardIndex);
-        const suffix = pattern.slice(wildcardIndex + 1);
-        if (!alias.startsWith(prefix) || !alias.endsWith(suffix))
-            continue;
-        const wildcard = alias.slice(prefix.length, alias.length - suffix.length);
-        return targets[0]?.replace("*", wildcard);
-    }
-    return undefined;
+export async function getDefaultAliases(projectDirectory) {
+    const tsConfig = await readTsConfig(projectDirectory);
+    const aliasPrefix = getAliasPrefix(tsConfig?.config.compilerOptions?.paths);
+    if (!aliasPrefix)
+        return defaultConfig.aliases;
+    return {
+        styles: `${aliasPrefix}styles`,
+        ui: `${aliasPrefix}components/ui`,
+    };
 }
 export async function resolveConfigAlias(projectDirectory, alias, name) {
-    if (alias.startsWith("@/")) {
-        return resolveConfigPath(projectDirectory, join("src", alias.slice(2)), name);
-    }
     const tsConfig = await readTsConfig(projectDirectory);
-    const target = tsConfig?.compilerOptions?.paths
-        ? resolvePathAlias(alias, tsConfig.compilerOptions.paths)
-        : undefined;
-    if (!target) {
-        throw new Error(`Could not resolve ${name} (${alias}). Add it to tsconfig.json or jsconfig.json compilerOptions.paths.`);
+    const paths = tsConfig?.config.compilerOptions?.paths;
+    // Only explicit paths mappings override the conventional @/src fallback.
+    const hasMatchingPath = paths &&
+        Object.keys(paths).some((pattern) => {
+            const wildcard = pattern.indexOf("*");
+            if (wildcard === -1)
+                return pattern === alias;
+            return (alias.startsWith(pattern.slice(0, wildcard)) && alias.endsWith(pattern.slice(wildcard + 1)));
+        });
+    if (tsConfig && hasMatchingPath) {
+        const targets = createPathsMatcher(tsConfig)?.(alias);
+        if (targets?.[0])
+            return resolveConfigPath(projectDirectory, targets[0], name);
+    }
+    else if (alias.startsWith("@/")) {
+        return resolveConfigPath(projectDirectory, join("src", alias.slice(2)), name);
     }
-    return resolveConfigPath(projectDirectory, join(tsConfig?.compilerOptions?.baseUrl ?? ".", target), name);
+    throw new Error(`Could not resolve ${name} (${alias}). Add it to tsconfig.json or jsconfig.json compilerOptions.paths.`);
 }

package/dist/dependencies.d.ts

@@ -1 +1,2 @@
 export declare function installDependencies(projectDirectory: string, dependencies: readonly string[], isDevelopmentDependency?: boolean): Promise<void>;
+export declare function getMissingDependencies(projectDirectory: string, dependencies: readonly string[]): Promise<readonly string[]>;

package/dist/dependencies.js

@@ -1,4 +1,6 @@
 import { spawn } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
 function detectPackageManager() {
     const userAgent = process.env.npm_config_user_agent ?? "";
     if (userAgent.startsWith("pnpm"))
@@ -13,10 +15,10 @@ export function installDependencies(projectDirectory, dependencies, isDevelopmen
     if (dependencies.length === 0)
         return Promise.resolve();
     const packageManager = detectPackageManager();
-    const developmentFlag = isDevelopmentDependency ? "-D" : undefined;
-    const arguments_ = packageManager === "npm"
-        ? ["install", developmentFlag, ...dependencies].filter((argument) => Boolean(argument))
-        : ["add", developmentFlag, ...dependencies].filter((argument) => Boolean(argument));
+    const arguments_ = [packageManager === "npm" ? "install" : "add"];
+    if (isDevelopmentDependency)
+        arguments_.push("-D");
+    arguments_.push(...dependencies);
     return new Promise((resolvePromise, reject) => {
         const child = spawn(packageManager, arguments_, { cwd: projectDirectory, stdio: "ignore" });
         child.on("error", reject);
@@ -28,3 +30,22 @@ export function installDependencies(projectDirectory, dependencies, isDevelopmen
         });
     });
 }
+function getPackageName(dependency) {
+    const versionStart = dependency.lastIndexOf("@");
+    return versionStart > 0 ? dependency.slice(0, versionStart) : dependency;
+}
+export async function getMissingDependencies(projectDirectory, dependencies) {
+    try {
+        const packageJson = JSON.parse(await readFile(resolve(projectDirectory, "package.json"), "utf8"));
+        const installedDependencies = new Set([
+            ...Object.keys(packageJson.dependencies ?? {}),
+            ...Object.keys(packageJson.devDependencies ?? {}),
+        ]);
+        return dependencies.filter((dependency) => !installedDependencies.has(getPackageName(dependency)));
+    }
+    catch (error) {
+        if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT")
+            return dependencies;
+        throw error;
+    }
+}