@bleedingdev/modern-js-create 3.5.0-ultramodern.4 → 3.5.0-ultramodern.40

package/dist/esm-node/cli/package-source.js

@@ -0,0 +1,120 @@
+import "node:module";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { fileURLToPath } from "node:url";
+import { resolveCreatePackageRoot } from "../create-package-root.js";
+import { BLEEDINGDEV_CREATE_PACKAGE, BLEEDINGDEV_FRAMEWORK_VERSION_ENV, BLEEDINGDEV_PACKAGE_NAME_PREFIX, BLEEDINGDEV_PACKAGE_SCOPE, WORKSPACE_PACKAGE_VERSION } from "../ultramodern-package-source.js";
+import { WORKSPACE_PROTOCOL_FLAG, getOptionValue } from "./flags.js";
+import { runSetupCommand } from "./project-setup.js";
+const package_source_dirname = node_path.dirname(fileURLToPath(import.meta.url));
+const createPackageRoot = resolveCreatePackageRoot(package_source_dirname);
+const semverPattern = /^(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+const REGISTRY_LOOKUP_TIMEOUT_MS = 15000;
+function readCreatePackageJson() {
+    const createPackageJson = node_path.join(createPackageRoot, 'package.json');
+    return JSON.parse(node_fs.readFileSync(createPackageJson, 'utf-8'));
+}
+function isBleedingDevCreatePackage(createPackage) {
+    return createPackage.name === BLEEDINGDEV_CREATE_PACKAGE;
+}
+function getBleedingDevFrameworkVersion(createPackage, fallbackVersion) {
+    const frameworkVersion = createPackage.ultramodern?.frameworkVersion;
+    return 'string' == typeof frameworkVersion && frameworkVersion.length > 0 ? frameworkVersion : fallbackVersion;
+}
+function detectUltramodernPackageSource(args, defaultPackageVersion, createPackage) {
+    const bleedingDevDefaults = isBleedingDevCreatePackage(createPackage);
+    const strategy = getOptionValue(args, [
+        '--ultramodern-package-source'
+    ]) ?? (bleedingDevDefaults ? 'install' : 'workspace');
+    if ('workspace' !== strategy && 'install' !== strategy) {
+        console.error('--ultramodern-package-source must be "workspace" or "install"');
+        process.exit(1);
+    }
+    const packageSourceStrategy = strategy;
+    const explicitRegistry = getOptionValue(args, [
+        '--ultramodern-package-registry'
+    ]);
+    const aliasScope = getOptionValue(args, [
+        '--ultramodern-package-scope'
+    ]) ?? (bleedingDevDefaults && 'install' === packageSourceStrategy && !explicitRegistry ? BLEEDINGDEV_PACKAGE_SCOPE : void 0);
+    return {
+        strategy: packageSourceStrategy,
+        modernPackageVersion: getOptionValue(args, [
+            '--ultramodern-package-version'
+        ]) ?? defaultPackageVersion,
+        registry: explicitRegistry,
+        aliasScope,
+        aliasPackageNamePrefix: getOptionValue(args, [
+            '--ultramodern-package-name-prefix'
+        ]) ?? (aliasScope ? BLEEDINGDEV_PACKAGE_NAME_PREFIX : void 0)
+    };
+}
+function hasExplicitUltramodernPackageSource(args, value) {
+    const configuredValue = getOptionValue(args, [
+        '--ultramodern-package-source'
+    ]);
+    return value ? configuredValue === value : void 0 !== configuredValue;
+}
+function readBleedingDevFrameworkVersionFromRegistry(fallbackVersion) {
+    const envVersion = process.env[BLEEDINGDEV_FRAMEWORK_VERSION_ENV]?.trim();
+    if (envVersion) {
+        if (!semverPattern.test(envVersion)) {
+            console.error(`${BLEEDINGDEV_FRAMEWORK_VERSION_ENV} must be a valid semver version`);
+            process.exit(1);
+        }
+        return envVersion;
+    }
+    try {
+        const rawVersion = runSetupCommand('npm', [
+            'view',
+            `${BLEEDINGDEV_CREATE_PACKAGE}@latest`,
+            'ultramodern.frameworkVersion',
+            '--json'
+        ], {
+            timeoutMs: REGISTRY_LOOKUP_TIMEOUT_MS
+        }).trim();
+        const version = JSON.parse(rawVersion);
+        if ('string' == typeof version && semverPattern.test(version)) return version;
+    } catch  {}
+    console.warn([
+        `Could not resolve ${BLEEDINGDEV_CREATE_PACKAGE}@latest ultramodern.frameworkVersion from the npm registry.`,
+        `Falling back to the packaged framework version ${fallbackVersion}.`,
+        `Pass ${WORKSPACE_PROTOCOL_FLAG} to use local workspace protocol dependencies,`,
+        'or pass --ultramodern-package-version with the exact BleedingDev framework cohort.'
+    ].join(' '));
+    return fallbackVersion;
+}
+function resolveInstallBackedPackageSource(args, createPackage, packageSource) {
+    const explicitVersion = getOptionValue(args, [
+        '--ultramodern-package-version'
+    ]);
+    const explicitRegistry = getOptionValue(args, [
+        '--ultramodern-package-registry'
+    ]);
+    const aliasScope = getOptionValue(args, [
+        '--ultramodern-package-scope'
+    ]) ?? packageSource.aliasScope ?? (explicitRegistry ? void 0 : BLEEDINGDEV_PACKAGE_SCOPE);
+    return {
+        ...packageSource,
+        strategy: 'install',
+        modernPackageVersion: explicitVersion ?? (isBleedingDevCreatePackage(createPackage) ? packageSource.modernPackageVersion : readBleedingDevFrameworkVersionFromRegistry(packageSource.modernPackageVersion)),
+        aliasScope,
+        aliasPackageNamePrefix: getOptionValue(args, [
+            '--ultramodern-package-name-prefix'
+        ]) ?? packageSource.aliasPackageNamePrefix ?? (aliasScope ? BLEEDINGDEV_PACKAGE_NAME_PREFIX : void 0)
+    };
+}
+function resolveWorkspacePackageSource(args, createPackage, packageSource) {
+    const workspaceProtocolRequested = args.includes(WORKSPACE_PROTOCOL_FLAG);
+    if (workspaceProtocolRequested && hasExplicitUltramodernPackageSource(args, 'install')) {
+        console.error(`${WORKSPACE_PROTOCOL_FLAG} conflicts with --ultramodern-package-source=install`);
+        process.exit(1);
+    }
+    if (workspaceProtocolRequested || hasExplicitUltramodernPackageSource(args, 'workspace')) return {
+        ...packageSource,
+        strategy: 'workspace',
+        modernPackageVersion: WORKSPACE_PACKAGE_VERSION
+    };
+    return resolveInstallBackedPackageSource(args, createPackage, packageSource);
+}
+export { detectUltramodernPackageSource, getBleedingDevFrameworkVersion, isBleedingDevCreatePackage, readCreatePackageJson, resolveWorkspacePackageSource };

package/dist/esm-node/cli/project-setup.js

@@ -0,0 +1,82 @@
+import "node:module";
+import { execFileSync } from "node:child_process";
+import node_fs from "node:fs";
+function runSetupCommand(command, args, options = {}) {
+    return execFileSync(command, args, {
+        cwd: options.cwd,
+        encoding: 'utf-8',
+        stdio: options.stdio ?? [
+            'ignore',
+            'pipe',
+            'pipe'
+        ],
+        timeout: options.timeoutMs
+    });
+}
+function commandExists(command) {
+    try {
+        runSetupCommand(command, [
+            '--version'
+        ], {
+            stdio: 'ignore'
+        });
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function assertGitAvailableForGeneratedProject() {
+    if (commandExists('git')) return;
+    throw new Error('Git is required for UltraModern setup. Install git yourself (for example "brew install git" or "sudo apt-get install git") and rerun create. This tool never installs system packages on your behalf.');
+}
+function isInsideGitWorkTree(targetDir) {
+    try {
+        return 'true' === runSetupCommand('git', [
+            'rev-parse',
+            '--is-inside-work-tree'
+        ], {
+            cwd: targetDir
+        }).trim();
+    } catch  {
+        return false;
+    }
+}
+function initializeGeneratedGitRepository(targetDir) {
+    assertGitAvailableForGeneratedProject();
+    if (isInsideGitWorkTree(targetDir)) return;
+    try {
+        runSetupCommand('git', [
+            'init',
+            '-b',
+            'main'
+        ], {
+            cwd: targetDir,
+            stdio: 'inherit'
+        });
+    } catch  {
+        runSetupCommand('git', [
+            'init'
+        ], {
+            cwd: targetDir,
+            stdio: 'inherit'
+        });
+        runSetupCommand('git', [
+            'branch',
+            '-M',
+            'main'
+        ], {
+            cwd: targetDir,
+            stdio: 'inherit'
+        });
+    }
+}
+function isDirectoryEmpty(dirPath) {
+    if (!node_fs.existsSync(dirPath)) return false;
+    try {
+        const files = node_fs.readdirSync(dirPath);
+        return 0 === files.length;
+    } catch  {
+        return false;
+    }
+}
+export { commandExists, initializeGeneratedGitRepository, isDirectoryEmpty, runSetupCommand };

package/dist/esm-node/cli/prompts.js

@@ -0,0 +1,52 @@
+import "node:module";
+import node_path from "node:path";
+import node_readline from "node:readline";
+import { i18n, localeKeys } from "../locale/index.js";
+import { collectPositionalArgs } from "./flags.js";
+import { isDirectoryEmpty } from "./project-setup.js";
+function promptInput(question) {
+    const rl = node_readline.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve)=>{
+        rl.question(question, (answer)=>{
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+async function getProjectName() {
+    const args = process.argv.slice(2);
+    const positionalArgs = collectPositionalArgs(args);
+    if (positionalArgs.length > 1) {
+        console.error(`Unexpected positional argument: ${positionalArgs[1]}`);
+        process.exit(1);
+    }
+    const projectNameArg = positionalArgs[0];
+    if (projectNameArg) {
+        if ('.' === projectNameArg) return {
+            name: node_path.basename(process.cwd()),
+            useCurrentDir: true
+        };
+        return {
+            name: projectNameArg,
+            useCurrentDir: false
+        };
+    }
+    const currentDir = process.cwd();
+    if (isDirectoryEmpty(currentDir)) return {
+        name: node_path.basename(currentDir),
+        useCurrentDir: true
+    };
+    const projectName = await promptInput(i18n.t(localeKeys.prompt.projectName));
+    if (!projectName) {
+        console.error(i18n.t(localeKeys.error.projectNameEmpty));
+        process.exit(1);
+    }
+    return {
+        name: projectName,
+        useCurrentDir: false
+    };
+}
+export { getProjectName };