create-nudge-ui 0.1.3 → 0.2.0

package/README.md

@@ -11,7 +11,7 @@ npm create nudge-ui@latest
 
 The initializer supports Next.js, Astro, Vite with React, and static HTML. Host
 frameworks take precedence over their underlying tools, so an Astro project
-with React islands receives `@nudge-ui/astro`, not `@nudge-ui/vite-react`.
+with React islands receives `nudge-ui/astro`, not `nudge-ui/vite`.
 
 Use an explicit framework when automatic detection is ambiguous:
 

package/dist/cli.js

@@ -4,7 +4,7 @@ import { stdin, stdout } from "node:process";
 import { basename, relative } from "node:path";
 import { parseArguments, helpText } from "./arguments.js";
 import { planConfiguration } from "./configuration.js";
-import { adapterPackage, detectFrameworks, detectPackageManager, detectStaticRoot, frameworkDisplayName, readProjectManifest, } from "./detection.js";
+import { detectFrameworks, detectPackageManager, detectStaticRoot, frameworkDisplayName, readProjectManifest, } from "./detection.js";
 import { formatCommand, installCommand, installPackage } from "./installer.js";
 import { frameworks } from "./types.js";
 /** Runs the Nudge UI project initializer. */
@@ -18,8 +18,9 @@ export async function runCli(args = process.argv.slice(2), projectRoot = process
     const detected = detectFrameworks(projectRoot, manifest);
     const framework = options.framework ?? await selectFramework(detected);
     const packageManager = options.packageManager ?? detectPackageManager(projectRoot, manifest);
-    const packageName = adapterPackage(framework);
-    const command = installCommand(packageManager, packageName);
+    // One package serves every host; the framework only decides which
+    // subpath the generated configuration imports.
+    const command = installCommand(packageManager, "nudge-ui");
     const change = planConfiguration(projectRoot, framework);
     const staticRoot = framework === "standalone" ? detectStaticRoot(projectRoot) : undefined;
     const serveDirectory = staticRoot ? relative(projectRoot, staticRoot) || "." : ".";
@@ -49,7 +50,7 @@ export async function runCli(args = process.argv.slice(2), projectRoot = process
     if (framework === "standalone") {
         stdout.write(`Run \`nudge-ui serve ${serveDirectory}\` to start the instrumented development server.\n`);
     }
-    stdout.write(`Nudge UI is configured with ${packageName}.\n`);
+    stdout.write(`Nudge UI is configured for ${frameworkDisplayName(framework)}.\n`);
 }
 async function selectFramework(detected) {
     if (detected.length === 1)

package/dist/configuration.js

@@ -3,7 +3,20 @@ import { join } from "node:path";
 import ts from "typescript";
 const nextConfigNames = ["next.config.ts", "next.config.mts", "next.config.mjs", "next.config.js", "next.config.cjs"];
 const astroConfigNames = ["astro.config.ts", "astro.config.mts", "astro.config.mjs", "astro.config.js"];
-const viteConfigNames = ["vite.config.ts", "vite.config.mts", "vite.config.mjs", "vite.config.js"];
+/**
+ * Vite's own `DEFAULT_CONFIG_FILES` order. The list is order-sensitive: the
+ * first existing file wins for Vite, so it must win here too, or the installer
+ * edits a configuration Vite never loads (and creating a new `vite.config.mjs`
+ * beside a `vite.config.cjs` would silently shadow it).
+ */
+const viteConfigNames = [
+    "vite.config.js",
+    "vite.config.mjs",
+    "vite.config.ts",
+    "vite.config.cjs",
+    "vite.config.mts",
+    "vite.config.cts",
+];
 /** Plans an idempotent host-configuration edit without writing to the project. */
 export function planConfiguration(projectRoot, framework) {
     if (framework === "standalone")
@@ -22,45 +35,59 @@ export function planConfiguration(projectRoot, framework) {
 export function configureSource(source, framework, fileName) {
     const sourceFile = parseSource(source, fileName);
     if (framework === "astro") {
-        return configureArrayHost(source, sourceFile, "@nudge-ui/astro", "nudgeUiAstro", "integrations", "nudgeUiAstro()");
+        return configureAstroSource(source, sourceFile);
     }
     if (framework === "vite-react") {
-        return configureArrayHost(source, sourceFile, "@nudge-ui/vite-react", "nudgeUi", "plugins", "...nudgeUi()");
+        return configureViteSource(source, sourceFile);
     }
     return configureNextSource(source, sourceFile);
 }
-function configureArrayHost(source, sourceFile, packageName, importName, propertyName, expression) {
-    const bindings = importedBindings(sourceFile, packageName, importName);
-    const callableBindings = new Set([...bindings, importName]);
-    const configObject = findDefineConfigObject(sourceFile, propertyName);
-    const matchingProperties = configObject.properties.filter((property) => propertyText(property.name) === propertyName);
-    if (matchingProperties.length > 1) {
-        throw new Error(`Could not update ${propertyName}: the configuration contains duplicate ${propertyName} properties.`);
+function configureViteSource(source, sourceFile) {
+    const packageName = "nudge-ui/vite";
+    const importName = "withNudgeUi";
+    const target = findConfigExport(sourceFile, "Vite");
+    const bindings = target.commonJs
+        ? requiredBindings(sourceFile, packageName, importName)
+        : importedBindings(sourceFile, packageName, importName);
+    const wrapperBinding = bindings[0] ?? unusedBindingName(sourceFile, importName);
+    const callableBindings = new Set([...bindings, wrapperBinding]);
+    const edits = [];
+    if (!containsCall(target.expression, callableBindings)) {
+        const start = target.expression.getStart(sourceFile);
+        const end = target.expression.getEnd();
+        edits.push({ start, end, text: `${wrapperBinding}(${source.slice(start, end)})` });
     }
-    const property = matchingProperties[0];
-    let configurationEdit;
-    if (property) {
-        if (!ts.isPropertyAssignment(property) || !ts.isArrayLiteralExpression(property.initializer)) {
-            throw new Error(`Could not update ${propertyName}: expected ${propertyName} to be an array.`);
-        }
-        if (!containsCall(property.initializer, callableBindings)) {
-            configurationEdit = insertArrayElement(source, sourceFile, property, expression);
-        }
+    if (bindings.length === 0) {
+        const statement = target.commonJs
+            ? `const { ${importName}${wrapperBinding === importName ? "" : `: ${wrapperBinding}`} } = require("${packageName}");`
+            : `import { ${importName}${wrapperBinding === importName ? "" : ` as ${wrapperBinding}`} } from "${packageName}";`;
+        edits.push(importEdit(sourceFile, statement, target.commonJs));
     }
-    else {
-        configurationEdit = insertObjectProperty(source, sourceFile, configObject, propertyName, expression);
+    return applyEdits(source, edits);
+}
+function configureAstroSource(source, sourceFile) {
+    const target = findDefaultExport(sourceFile, "Astro");
+    const bindings = importedBindings(sourceFile, "nudge-ui/astro", "withNudgeUi");
+    const wrapperBinding = bindings[0] ?? unusedBindingName(sourceFile, "withNudgeUi");
+    const edits = [];
+    if (!containsCall(target, new Set(bindings))) {
+        const start = target.getStart(sourceFile);
+        const end = target.getEnd();
+        edits.push({ start, end, text: `${wrapperBinding}(${source.slice(start, end)})` });
     }
-    const edits = configurationEdit ? [configurationEdit] : [];
     if (bindings.length === 0) {
-        edits.push(importEdit(sourceFile, `import { ${importName} } from "${packageName}";`, false));
+        const importedName = wrapperBinding === "withNudgeUi"
+            ? "withNudgeUi"
+            : `withNudgeUi as ${wrapperBinding}`;
+        edits.push(importEdit(sourceFile, `import { ${importedName} } from "nudge-ui/astro";`, false));
     }
     return applyEdits(source, edits);
 }
 function configureNextSource(source, sourceFile) {
-    const target = findNextExport(sourceFile);
+    const target = findConfigExport(sourceFile, "Next.js");
     const bindings = target.commonJs
-        ? requiredBindings(sourceFile, "@nudge-ui/nextjs", "withNudgeUi")
-        : importedBindings(sourceFile, "@nudge-ui/nextjs", "withNudgeUi");
+        ? requiredBindings(sourceFile, "nudge-ui/next", "withNudgeUi")
+        : importedBindings(sourceFile, "nudge-ui/next", "withNudgeUi");
     const callableBindings = new Set([...bindings, "withNudgeUi"]);
     const edits = [];
     if (!containsCall(target.expression, callableBindings)) {
@@ -70,34 +97,19 @@ function configureNextSource(source, sourceFile) {
     }
     if (bindings.length === 0) {
         const statement = target.commonJs
-            ? 'const { withNudgeUi } = require("@nudge-ui/nextjs");'
-            : 'import { withNudgeUi } from "@nudge-ui/nextjs";';
+            ? 'const { withNudgeUi } = require("nudge-ui/next");'
+            : 'import { withNudgeUi } from "nudge-ui/next";';
         edits.push(importEdit(sourceFile, statement, target.commonJs));
     }
     return applyEdits(source, edits);
 }
 function parseSource(source, fileName) {
-    const scriptKind = fileName.endsWith(".ts") || fileName.endsWith(".mts")
+    const scriptKind = /\.(?:ts|mts|cts)$/.test(fileName)
         ? ts.ScriptKind.TS
         : ts.ScriptKind.JS;
     return ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, scriptKind);
 }
-function findDefineConfigObject(sourceFile, propertyName) {
-    const candidates = [];
-    visit(sourceFile, (node) => {
-        if (ts.isCallExpression(node)
-            && ts.isIdentifier(node.expression)
-            && node.expression.text === "defineConfig"
-            && node.arguments[0]
-            && ts.isObjectLiteralExpression(node.arguments[0]))
-            candidates.push(node.arguments[0]);
-    });
-    if (candidates.length !== 1) {
-        throw new Error(`Could not update ${propertyName}: expected exactly one defineConfig({ ... }) call.`);
-    }
-    return candidates[0];
-}
-function findNextExport(sourceFile) {
+function findConfigExport(sourceFile, frameworkName) {
     const exports = [];
     for (const statement of sourceFile.statements) {
         if (ts.isExportAssignment(statement) && !statement.isExportEquals) {
@@ -112,7 +124,16 @@ function findNextExport(sourceFile) {
         exports.push({ expression: assignment.right, commonJs: true });
     }
     if (exports.length !== 1) {
-        throw new Error("Could not update the Next.js configuration: expected exactly one default or module.exports assignment.");
+        throw new Error(`Could not update the ${frameworkName} configuration: expected exactly one default or module.exports assignment.`);
+    }
+    return exports[0];
+}
+function findDefaultExport(sourceFile, frameworkName) {
+    const exports = sourceFile.statements
+        .filter((statement) => ts.isExportAssignment(statement) && !statement.isExportEquals)
+        .map((statement) => statement.expression);
+    if (exports.length !== 1) {
+        throw new Error(`Could not update the ${frameworkName} configuration: expected exactly one default export.`);
     }
     return exports[0];
 }
@@ -180,46 +201,23 @@ function containsCall(root, bindingNames) {
     });
     return found;
 }
+function unusedBindingName(sourceFile, preferred) {
+    const identifiers = new Set();
+    visit(sourceFile, (node) => {
+        if (ts.isIdentifier(node))
+            identifiers.add(node.text);
+    });
+    if (!identifiers.has(preferred))
+        return preferred;
+    let suffix = 2;
+    while (identifiers.has(`${preferred}${suffix}`))
+        suffix += 1;
+    return `${preferred}${suffix}`;
+}
 function visit(root, visitor) {
     visitor(root);
     ts.forEachChild(root, (child) => visit(child, visitor));
 }
-function propertyText(name) {
-    if (!name)
-        return undefined;
-    if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name))
-        return name.text;
-    if (ts.isComputedPropertyName(name) && ts.isStringLiteral(name.expression))
-        return name.expression.text;
-    return undefined;
-}
-function insertArrayElement(source, sourceFile, property, expression) {
-    const array = property.initializer;
-    if (!ts.isArrayLiteralExpression(array))
-        throw new Error("Expected an array property.");
-    const start = array.getStart(sourceFile) + 1;
-    const end = array.getEnd() - 1;
-    const indentation = lineIndentation(source, property.getStart(sourceFile));
-    const elementIndentation = `${indentation}  `;
-    const interior = source.slice(start, end);
-    if (interior.trim() === "") {
-        return { start, end, text: `\n${elementIndentation}${expression},\n${indentation}` };
-    }
-    const text = interior.startsWith("\n")
-        ? `\n${elementIndentation}${expression},`
-        : `\n${elementIndentation}${expression},\n${elementIndentation}`;
-    return { start, end: start, text };
-}
-function insertObjectProperty(source, sourceFile, object, propertyName, expression) {
-    const start = object.getStart(sourceFile) + 1;
-    const indentation = lineIndentation(source, object.getStart(sourceFile));
-    const propertyIndentation = `${indentation}  `;
-    const empty = object.properties.length === 0;
-    const text = empty
-        ? `\n${propertyIndentation}${propertyName}: [${expression}],\n${indentation}`
-        : `\n${propertyIndentation}${propertyName}: [${expression}],`;
-    return { start, end: start, text };
-}
 function importEdit(sourceFile, statement, commonJs) {
     const imports = sourceFile.statements.filter(ts.isImportDeclaration);
     const lastImport = imports.at(-1);
@@ -235,11 +233,6 @@ function importEdit(sourceFile, statement, commonJs) {
     const start = firstStatement?.getStart(sourceFile) ?? sourceFile.getEnd();
     return { start, end: start, text: `${statement}\n` };
 }
-function lineIndentation(source, position) {
-    const lineStart = source.lastIndexOf("\n", position - 1) + 1;
-    const match = /^[ \t]*/.exec(source.slice(lineStart, position));
-    return match?.[0] ?? "";
-}
 function applyEdits(source, edits) {
     return [...edits]
         .sort((left, right) => right.start - left.start)

package/dist/detection.d.ts

@@ -8,4 +8,3 @@ export declare function detectPackageManager(projectRoot: string, manifest?: Pro
 /** Finds an HTML document root without recursively scanning dependency or build output. */
 export declare function detectStaticRoot(projectRoot: string): string | undefined;
 export declare function frameworkDisplayName(framework: Framework): string;
-export declare function adapterPackage(framework: Framework): string;

package/dist/detection.js

@@ -57,7 +57,7 @@ export function detectFrameworks(projectRoot, manifest = readProjectManifest(pro
         return ["vite-react"];
     if (hasVite)
         return [];
-    if (manifest.dependencies.has("@nudge-ui/standalone") || detectStaticRoot(projectRoot))
+    if (manifest.dependencies.has("nudge-ui") || detectStaticRoot(projectRoot))
         return ["standalone"];
     return [];
 }
@@ -107,15 +107,6 @@ export function frameworkDisplayName(framework) {
         return "Vite with React";
     return "static HTML";
 }
-export function adapterPackage(framework) {
-    if (framework === "nextjs")
-        return "@nudge-ui/nextjs";
-    if (framework === "astro")
-        return "@nudge-ui/astro";
-    if (framework === "vite-react")
-        return "@nudge-ui/vite-react";
-    return "@nudge-ui/standalone";
-}
 function hasAnyFile(projectRoot, names) {
     return names.some((name) => existsSync(join(projectRoot, name)));
 }

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { parseArguments, helpText, type CliOptions } from "./arguments.js";
 export { configureSource, planConfiguration } from "./configuration.js";
-export { adapterPackage, detectFrameworks, detectPackageManager, detectStaticRoot, frameworkDisplayName, readProjectManifest, } from "./detection.js";
+export { detectFrameworks, detectPackageManager, detectStaticRoot, frameworkDisplayName, readProjectManifest, } from "./detection.js";
 export { formatCommand, installCommand, type InstallCommand } from "./installer.js";
 export { frameworks, packageManagers, type Framework, type PackageManager } from "./types.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 export { parseArguments, helpText } from "./arguments.js";
 export { configureSource, planConfiguration } from "./configuration.js";
-export { adapterPackage, detectFrameworks, detectPackageManager, detectStaticRoot, frameworkDisplayName, readProjectManifest, } from "./detection.js";
+export { detectFrameworks, detectPackageManager, detectStaticRoot, frameworkDisplayName, readProjectManifest, } from "./detection.js";
 export { formatCommand, installCommand } from "./installer.js";
 export { frameworks, packageManagers } from "./types.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-nudge-ui",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "Framework-detecting installer for Nudge UI.",
   "license": "MIT",
   "repository": {