minidev-buildconfig-cli 0.0.1

package/dist/cli.js

@@ -0,0 +1,74 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const generate_config_ts_1 = require("./core/generate-config.js");
+function printUsage() {
+    console.error('Usage: minidev-buildconfig generate --env <env> [--cwd <path>] [--lang ts|js]');
+}
+function parseGenerateArgs(argv) {
+    const options = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        const value = argv[index + 1];
+        if (arg === '--env') {
+            options.env = value;
+            index += 1;
+            continue;
+        }
+        if (arg === '--cwd') {
+            options.cwd = value;
+            index += 1;
+            continue;
+        }
+        if (arg === '--platform') {
+            options.platform = value;
+            index += 1;
+            continue;
+        }
+        if (arg === '--miniprogramRoot') {
+            options.miniprogramRoot = value;
+            index += 1;
+            continue;
+        }
+        if (arg === '--output') {
+            options.output = value;
+            index += 1;
+            continue;
+        }
+        if (arg === '--lang') {
+            if (value !== 'ts' && value !== 'js') {
+                throw new Error(`Invalid --lang: ${value}. Must be ts or js.`);
+            }
+            options.lang = value;
+            index += 1;
+            continue;
+        }
+        throw new Error(`Unknown argument: ${arg}`);
+    }
+    if (!options.env) {
+        throw new Error('Missing required option: --env');
+    }
+    return options;
+}
+async function main() {
+    const [, , command, ...rest] = process.argv;
+    if (command !== 'generate') {
+        printUsage();
+        process.exitCode = 1;
+        return;
+    }
+    try {
+        const options = parseGenerateArgs(rest);
+        const result = await (0, generate_config_ts_1.generateConfig)(options);
+        console.log(`Generated configs for ${result.env}:`);
+        for (const output of result.outputs) {
+            console.log(`  ${output.configName}: ${output.outputPath}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(message);
+        process.exitCode = 1;
+    }
+}
+void main();

package/dist/core/detect-platform.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeMiniprogramRoot = normalizeMiniprogramRoot;
+exports.detectPlatformFromJsonFile = detectPlatformFromJsonFile;
+exports.detectPlatformCandidates = detectPlatformCandidates;
+exports.detectPlatforms = detectPlatforms;
+exports.detectLang = detectLang;
+const node_path_1 = __importDefault(require("node:path"));
+const promises_1 = require("node:fs/promises");
+function normalizeMiniprogramRoot(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const normalized = value.replace(/\/+$/, '');
+    return normalized.length > 0 ? normalized : null;
+}
+async function detectPlatformFromJsonFile(options) {
+    const configPath = node_path_1.default.join(options.cwd, options.configFile);
+    let content;
+    try {
+        const { readFile } = await import('node:fs/promises');
+        content = await readFile(configPath, 'utf8');
+    }
+    catch (error) {
+        const errorCode = typeof error === 'object' && error !== null && 'code' in error
+            ? error.code
+            : undefined;
+        if (errorCode === 'ENOENT') {
+            return null;
+        }
+        throw error;
+    }
+    const config = JSON.parse(content);
+    const miniprogramRoot = normalizeMiniprogramRoot(config.miniprogramRoot);
+    if (!miniprogramRoot) {
+        return null;
+    }
+    return {
+        platform: options.platform,
+        miniprogramRoot,
+        configFile: options.configFile,
+        configPath,
+    };
+}
+// Conflict resolution order is stable and explicit:
+// WeChat first, then Alipay, then TT, matching current fixture expectations
+// and giving downstream CLI code a deterministic candidate list for messages.
+const PLATFORM_DETECTORS = [
+    { platform: 'wechat', configFile: 'project.config.json' },
+    { platform: 'alipay', configFile: 'mini.project.json' },
+    { platform: 'tt', configFile: 'project.tt.json' },
+];
+async function detectPlatformCandidates(cwd) {
+    const candidates = [];
+    for (const detector of PLATFORM_DETECTORS) {
+        const candidate = await detectPlatformFromJsonFile({
+            cwd,
+            platform: detector.platform,
+            configFile: detector.configFile,
+        });
+        if (candidate) {
+            candidates.push(candidate);
+        }
+    }
+    return candidates;
+}
+async function detectPlatforms(cwd) {
+    const candidates = await detectPlatformCandidates(cwd);
+    return candidates.map(({ platform, miniprogramRoot }) => ({ platform, miniprogramRoot }));
+}
+/**
+ * Detect project language by checking for app.ts vs app.js in miniprogramRoot.
+ * Defaults to 'ts' if neither is found (assumes TypeScript project).
+ */
+async function detectLang(options) {
+    const entries = [];
+    try {
+        const appTsPath = node_path_1.default.join(options.cwd, options.miniprogramRoot, 'app.ts');
+        await (0, promises_1.access)(appTsPath);
+        entries.push('ts');
+    }
+    catch {
+        // app.ts not found
+    }
+    try {
+        const appJsPath = node_path_1.default.join(options.cwd, options.miniprogramRoot, 'app.js');
+        await (0, promises_1.access)(appJsPath);
+        entries.push('js');
+    }
+    catch {
+        // app.js not found
+    }
+    if (entries.includes('ts'))
+        return 'ts';
+    if (entries.includes('js'))
+        return 'js';
+    return 'ts';
+}

package/dist/core/generate-config.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateConfig = generateConfig;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const detect_platform_ts_1 = require("./detect-platform.js");
+const load_env_config_ts_1 = require("./load-env-config.js");
+const load_user_config_ts_1 = require("./load-user-config.js");
+const resolve_output_ts_1 = require("./resolve-output.js");
+function renderTsModule(config) {
+    return `const config = ${JSON.stringify(config, null, 2)} as const
+
+export type AppConfig = typeof config
+
+export default config
+`;
+}
+function renderJsModule(config) {
+    return `const config = ${JSON.stringify(config, null, 2)}
+
+module.exports = config
+`;
+}
+function renderConfigModule(config, lang) {
+    return lang === 'ts' ? renderTsModule(config) : renderJsModule(config);
+}
+function resolveCandidate(options) {
+    const requestedPlatform = options.platform;
+    const matchingCandidates = requestedPlatform
+        ? options.candidates.filter((candidate) => candidate.platform === requestedPlatform)
+        : options.candidates;
+    if (matchingCandidates.length === 1) {
+        return matchingCandidates[0];
+    }
+    if (matchingCandidates.length > 1) {
+        const platforms = matchingCandidates.map((candidate) => candidate.platform).join(', ');
+        throw new Error(`Multiple platforms detected: ${platforms}. Pass --platform <name> to disambiguate.`);
+    }
+    if (requestedPlatform) {
+        throw new Error(`Unable to detect platform: ${requestedPlatform}`);
+    }
+    throw new Error('Unable to detect miniprogramRoot. Set minidevBuildConfig.miniprogramRoot in package.json.');
+}
+async function generateConfig(options) {
+    const cwd = options.cwd ?? process.cwd();
+    const userConfig = await (0, load_user_config_ts_1.loadUserConfig)(cwd);
+    const envConfigs = await (0, load_env_config_ts_1.loadAllEnvConfigs)({
+        cwd,
+        env: options.env,
+        configDir: userConfig.configDir,
+    });
+    const candidates = await (0, detect_platform_ts_1.detectPlatformCandidates)(cwd);
+    const platform = options.platform ?? userConfig.platform;
+    const explicitMiniprogramRoot = options.miniprogramRoot ?? userConfig.miniprogramRoot;
+    const miniprogramRoot = explicitMiniprogramRoot ??
+        resolveCandidate({
+            candidates,
+            platform,
+        }).miniprogramRoot;
+    const detectedCandidate = candidates.find((candidate) => candidate.miniprogramRoot === miniprogramRoot) ??
+        (platform
+            ? candidates.find((candidate) => candidate.platform === platform)
+            : undefined);
+    const lang = options.lang ??
+        userConfig.lang ??
+        (await (0, detect_platform_ts_1.detectLang)({ cwd, miniprogramRoot }));
+    const outputs = [];
+    for (const [configName, configData] of Object.entries(envConfigs)) {
+        const configWithEnv = { env: options.env, ...configData };
+        const { outputFile, outputPath } = (0, resolve_output_ts_1.resolveNamedOutput)({
+            cwd,
+            miniprogramRoot,
+            configName,
+            lang,
+        });
+        const content = renderConfigModule(configWithEnv, lang);
+        await (0, promises_1.mkdir)(node_path_1.default.dirname(outputPath), { recursive: true });
+        await (0, promises_1.writeFile)(outputPath, content);
+        outputs.push({ configName, outputFile, outputPath });
+    }
+    return {
+        cwd,
+        env: options.env,
+        platform: platform ?? detectedCandidate?.platform,
+        miniprogramRoot,
+        lang,
+        outputs,
+    };
+}

package/dist/core/load-env-config.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAllEnvConfigs = loadAllEnvConfigs;
+exports.loadEnvConfig = loadEnvConfig;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const json5_1 = __importDefault(require("json5"));
+function validateEnvName(env) {
+    if (!/^[A-Za-z0-9_-]+$/.test(env)) {
+        throw new Error(`Invalid env: ${env}`);
+    }
+}
+function extractConfigName(filename, env) {
+    // Pattern: <configName>.<env>.json5 → configName
+    const suffix = `.${env}.json5`;
+    if (filename.endsWith(suffix)) {
+        const prefix = filename.slice(0, -suffix.length);
+        if (prefix.length > 0) {
+            return prefix;
+        }
+    }
+    return null;
+}
+async function loadAllEnvConfigs(options) {
+    validateEnvName(options.env);
+    const configDir = options.configDir ?? 'configs';
+    const configDirPath = node_path_1.default.join(options.cwd, configDir);
+    const entries = await (0, promises_1.readdir)(configDirPath, { withFileTypes: true });
+    const configs = {};
+    for (const entry of entries) {
+        if (!entry.isFile())
+            continue;
+        const configName = extractConfigName(entry.name, options.env);
+        if (configName === null)
+            continue;
+        const configPath = node_path_1.default.join(configDirPath, entry.name);
+        const configContent = await (0, promises_1.readFile)(configPath, 'utf8');
+        configs[configName] = json5_1.default.parse(configContent);
+    }
+    return configs;
+}
+/**
+ * @deprecated Use loadAllEnvConfigs for multi-file config support.
+ * Loads a single config file: <configDir>/<env>.json5
+ */
+async function loadEnvConfig(options) {
+    validateEnvName(options.env);
+    const configDir = options.configDir ?? 'configs';
+    const configPath = node_path_1.default.join(options.cwd, configDir, `${options.env}.json5`);
+    const configContent = await (0, promises_1.readFile)(configPath, 'utf8');
+    return json5_1.default.parse(configContent);
+}

package/dist/core/load-user-config.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadUserConfig = loadUserConfig;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+function readOptionalString(source, key) {
+    const value = source[key];
+    return typeof value === 'string' ? value : undefined;
+}
+async function loadUserConfig(cwd) {
+    const packageJsonPath = node_path_1.default.join(cwd, 'package.json');
+    let packageJsonContent;
+    try {
+        packageJsonContent = await (0, promises_1.readFile)(packageJsonPath, 'utf8');
+    }
+    catch (error) {
+        const errorCode = typeof error === 'object' && error !== null && 'code' in error
+            ? error.code
+            : undefined;
+        if (errorCode === 'ENOENT') {
+            return {
+                configDir: undefined,
+                platform: undefined,
+                miniprogramRoot: undefined,
+                lang: undefined,
+            };
+        }
+        throw error;
+    }
+    const packageJson = JSON.parse(packageJsonContent);
+    const rawConfig = packageJson.minidevBuildConfig ?? {};
+    const langValue = readOptionalString(rawConfig, 'lang');
+    const lang = langValue === 'ts' || langValue === 'js' ? langValue : undefined;
+    return {
+        configDir: readOptionalString(rawConfig, 'configDir'),
+        platform: readOptionalString(rawConfig, 'platform'),
+        miniprogramRoot: readOptionalString(rawConfig, 'miniprogramRoot'),
+        lang,
+    };
+}

package/dist/core/resolve-output.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveOutput = resolveOutput;
+exports.resolveNamedOutput = resolveNamedOutput;
+const node_path_1 = __importDefault(require("node:path"));
+function normalizeRelativePath(value) {
+    const normalized = value.replace(/\\/g, '/').replace(/^\.\/+/, '').replace(/\/+$/, '');
+    return normalized.length > 0 ? normalized : '';
+}
+function resolveOutput(options) {
+    const miniprogramRoot = normalizeRelativePath(options.miniprogramRoot);
+    const output = normalizeRelativePath(options.output ?? 'generated/config.ts');
+    const outputFile = node_path_1.default.posix.join(miniprogramRoot, output);
+    return {
+        outputFile,
+        outputPath: node_path_1.default.resolve(options.cwd, outputFile),
+    };
+}
+function resolveNamedOutput(options) {
+    const miniprogramRoot = normalizeRelativePath(options.miniprogramRoot);
+    const ext = options.lang ?? 'ts';
+    const outputFile = node_path_1.default.posix.join(miniprogramRoot, 'generated', `${options.configName}.${ext}`);
+    return {
+        outputFile,
+        outputPath: node_path_1.default.resolve(options.cwd, outputFile),
+    };
+}

package/dist/index.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadUserConfig = exports.loadEnvConfig = exports.loadAllEnvConfigs = exports.detectPlatforms = exports.detectLang = exports.resolveNamedOutput = exports.resolveOutput = exports.generateConfig = void 0;
+var generate_config_ts_1 = require("./core/generate-config.js");
+Object.defineProperty(exports, "generateConfig", { enumerable: true, get: function () { return generate_config_ts_1.generateConfig; } });
+var resolve_output_ts_1 = require("./core/resolve-output.js");
+Object.defineProperty(exports, "resolveOutput", { enumerable: true, get: function () { return resolve_output_ts_1.resolveOutput; } });
+Object.defineProperty(exports, "resolveNamedOutput", { enumerable: true, get: function () { return resolve_output_ts_1.resolveNamedOutput; } });
+var detect_platform_ts_1 = require("./core/detect-platform.js");
+Object.defineProperty(exports, "detectLang", { enumerable: true, get: function () { return detect_platform_ts_1.detectLang; } });
+Object.defineProperty(exports, "detectPlatforms", { enumerable: true, get: function () { return detect_platform_ts_1.detectPlatforms; } });
+var load_env_config_ts_1 = require("./core/load-env-config.js");
+Object.defineProperty(exports, "loadAllEnvConfigs", { enumerable: true, get: function () { return load_env_config_ts_1.loadAllEnvConfigs; } });
+Object.defineProperty(exports, "loadEnvConfig", { enumerable: true, get: function () { return load_env_config_ts_1.loadEnvConfig; } });
+var load_user_config_ts_1 = require("./core/load-user-config.js");
+Object.defineProperty(exports, "loadUserConfig", { enumerable: true, get: function () { return load_user_config_ts_1.loadUserConfig; } });

package/dist/platforms/alipay.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectAlipayProject = detectAlipayProject;
+const detect_platform_ts_1 = require("../core/detect-platform.js");
+async function detectAlipayProject(cwd) {
+    return (0, detect_platform_ts_1.detectPlatformFromJsonFile)({
+        cwd,
+        platform: 'alipay',
+        configFile: 'mini.project.json',
+    });
+}

package/dist/platforms/tt.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectTtProject = detectTtProject;
+const detect_platform_ts_1 = require("../core/detect-platform.js");
+async function detectTtProject(cwd) {
+    return (0, detect_platform_ts_1.detectPlatformFromJsonFile)({
+        cwd,
+        platform: 'tt',
+        configFile: 'project.tt.json',
+    });
+}

package/dist/platforms/wechat.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectWechatProject = detectWechatProject;
+const detect_platform_ts_1 = require("../core/detect-platform.js");
+async function detectWechatProject(cwd) {
+    return (0, detect_platform_ts_1.detectPlatformFromJsonFile)({
+        cwd,
+        platform: 'wechat',
+        configFile: 'project.config.json',
+    });
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "minidev-buildconfig-cli",
+  "version": "0.0.1",
+  "description": "CLI tool for generating mini program multi-environment config files",
+  "license": "MIT",
+  "author": "xesam",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/xesam/minidev-buildconfig-cli"
+  },
+  "keywords": [
+    "miniprogram",
+    "wechat",
+    "alipay",
+    "douyin",
+    "build-config",
+    "multi-environment",
+    "cli"
+  ],
+  "bin": {
+    "minidev-buildconfig": "dist/cli.js"
+  },
+  "main": "dist/index.js",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "node --experimental-strip-types --test tests/*.test.js"
+  },
+  "dependencies": {
+    "json5": "^2.2.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.15.30",
+    "typescript": "^5.8.3"
+  },
+  "files": [
+    "dist/"
+  ]
+}