@windrun-huaiin/dev-scripts 14.0.0 → 14.1.1

package/dist/_virtual/_commonjsHelpers.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+exports.getDefaultExportFromCjs = getDefaultExportFromCjs;

package/dist/_virtual/_commonjsHelpers.mjs

@@ -0,0 +1,5 @@
+function getDefaultExportFromCjs (x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
+}
+
+export { getDefaultExportFromCjs };

package/dist/_virtual/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _commonjsHelpers = require('./_commonjsHelpers.js');
+var index = require('../node_modules/.pnpm/semver@7.7.4/node_modules/semver/index.js');
+
+var semverExports = index.__require();
+var semver = /*@__PURE__*/_commonjsHelpers.getDefaultExportFromCjs(semverExports);
+
+exports.default = semver;

package/dist/_virtual/index.mjs

@@ -0,0 +1,7 @@
+import { getDefaultExportFromCjs } from './_commonjsHelpers.mjs';
+import { __require as requireSemver } from '../node_modules/.pnpm/semver@7.7.4/node_modules/semver/index.mjs';
+
+var semverExports = requireSemver();
+var semver = /*@__PURE__*/getDefaultExportFromCjs(semverExports);
+
+export { semver as default };

package/dist/_virtual/re.js

@@ -0,0 +1,5 @@
+'use strict';
+
+var re = {exports: {}};
+
+exports.__module = re;

package/dist/_virtual/re.mjs

@@ -0,0 +1,3 @@
+var re = {exports: {}};
+
+export { re as __module };

package/dist/cli.js

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
 'use strict';
 
+var fs = require('fs');
+var path = require('path');
 var commander = require('commander');
 var index = require('./config/index.js');
 var checkTranslations = require('./commands/check-translations.js');
@@ -11,13 +13,16 @@ var easyChangeset = require('./commands/easy-changeset.js');
 var generateNextjsArchitecture = require('./commands/generate-nextjs-architecture.js');
 var createDiaomaoApp = require('./commands/create-diaomao-app.js');
 var backendCore = require('./commands/backend-core.js');
+var diaomaoUpdate = require('./commands/diaomao-update.js');
 
 // get current working directory, ensure it works in Node.js environment
 const cwd = typeof process !== 'undefined' ? process.cwd() : '.';
+const cliPackageJsonPath = path.resolve(__dirname, '../package.json');
+const cliPackageJson = JSON.parse(fs.readFileSync(cliPackageJsonPath, 'utf8'));
 commander.program
     .name('dev-scripts')
     .description('development scripts for multi-language projects')
-    .version('5.0.0');
+    .version(cliPackageJson.version || '0.0.0');
 commander.program
     .command('check-translations')
     .description('check the completeness and consistency of translation files')
@@ -155,6 +160,33 @@ commander.program
         }
     }
 });
+commander.program
+    .command('diaomao-update')
+    .description('sync allowed dependency versions from the remote diaomao workspace source')
+    .option('-v, --verbose', 'show detailed logs', false)
+    .action(async (options) => {
+    try {
+        const config = index.loadConfig(cwd, {
+            diaomaoUpdate: {
+                compactLog: options.verbose ? false : undefined
+            }
+        }, options.verbose);
+        if (options.verbose) {
+            config.output.verbose = true;
+        }
+        index.validateConfig(config);
+        const exitCode = await diaomaoUpdate.diaomaoUpdate(config, cwd);
+        if (typeof process !== 'undefined') {
+            process.exit(exitCode);
+        }
+    }
+    catch (error) {
+        console.error('Error:', error);
+        if (typeof process !== 'undefined') {
+            process.exit(1);
+        }
+    }
+});
 commander.program
     .command('create-diaomao-app <project-name>')
     .description('create a new diaomao app from template')

package/dist/cli.mjs

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
 import { program } from 'commander';
 import { loadConfig, validateConfig } from './config/index.mjs';
 import { checkTranslations } from './commands/check-translations.mjs';
@@ -9,13 +11,16 @@ import { easyChangeset } from './commands/easy-changeset.mjs';
 import { generateNextjsArchitecture } from './commands/generate-nextjs-architecture.mjs';
 import { createDiaomaoApp } from './commands/create-diaomao-app.mjs';
 import { registerBackendCoreCommands } from './commands/backend-core.mjs';
+import { diaomaoUpdate } from './commands/diaomao-update.mjs';
 
 // get current working directory, ensure it works in Node.js environment
 const cwd = typeof process !== 'undefined' ? process.cwd() : '.';
+const cliPackageJsonPath = path.resolve(__dirname, '../package.json');
+const cliPackageJson = JSON.parse(fs.readFileSync(cliPackageJsonPath, 'utf8'));
 program
     .name('dev-scripts')
     .description('development scripts for multi-language projects')
-    .version('5.0.0');
+    .version(cliPackageJson.version || '0.0.0');
 program
     .command('check-translations')
     .description('check the completeness and consistency of translation files')
@@ -153,6 +158,33 @@ program
         }
     }
 });
+program
+    .command('diaomao-update')
+    .description('sync allowed dependency versions from the remote diaomao workspace source')
+    .option('-v, --verbose', 'show detailed logs', false)
+    .action(async (options) => {
+    try {
+        const config = loadConfig(cwd, {
+            diaomaoUpdate: {
+                compactLog: options.verbose ? false : undefined
+            }
+        }, options.verbose);
+        if (options.verbose) {
+            config.output.verbose = true;
+        }
+        validateConfig(config);
+        const exitCode = await diaomaoUpdate(config, cwd);
+        if (typeof process !== 'undefined') {
+            process.exit(exitCode);
+        }
+    }
+    catch (error) {
+        console.error('Error:', error);
+        if (typeof process !== 'undefined') {
+            process.exit(1);
+        }
+    }
+});
 program
     .command('create-diaomao-app <project-name>')
     .description('create a new diaomao app from template')

package/dist/commands/diaomao-update.d.ts

@@ -0,0 +1,3 @@
+import { DevScriptsConfig } from '@dev-scripts/config/schema';
+export declare function diaomaoUpdate(config: DevScriptsConfig, cwd?: string): Promise<number>;
+//# sourceMappingURL=diaomao-update.d.ts.map

package/dist/commands/diaomao-update.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diaomao-update.d.ts","sourceRoot":"","sources":["../../src/commands/diaomao-update.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AA0O7D,wBAAsB,aAAa,CACjC,MAAM,EAAE,gBAAgB,EACxB,GAAG,GAAE,MAA6D,GACjE,OAAO,CAAC,MAAM,CAAC,CA6LjB"}

package/dist/commands/diaomao-update.js

@@ -0,0 +1,336 @@
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var https = require('https');
+var yaml = require('yaml');
+var semver = require('semver');
+
+const DEPENDENCY_SECTIONS = [
+    'dependencies',
+    'devDependencies',
+    'peerDependencies',
+    'optionalDependencies'
+];
+function fetchText(url) {
+    return new Promise((resolve, reject) => {
+        const request = https.get(url, (response) => {
+            const statusCode = response.statusCode ?? 0;
+            if (statusCode >= 300 && statusCode < 400 && response.headers.location) {
+                response.resume();
+                fetchText(response.headers.location).then(resolve).catch(reject);
+                return;
+            }
+            if (statusCode < 200 || statusCode >= 300) {
+                response.resume();
+                reject(new Error(`failed to fetch update source: ${statusCode}`));
+                return;
+            }
+            let body = '';
+            response.setEncoding('utf8');
+            response.on('data', (chunk) => {
+                body += chunk;
+            });
+            response.on('end', () => resolve(body));
+        });
+        request.on('error', (error) => reject(error));
+    });
+}
+function findNearestFile(startDir, fileName) {
+    let currentDir = startDir;
+    while (true) {
+        const candidate = path.join(currentDir, fileName);
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+        const parentDir = path.dirname(currentDir);
+        if (parentDir === currentDir) {
+            return null;
+        }
+        currentDir = parentDir;
+    }
+}
+function stripProtocolPrefix(version) {
+    const protocolPrefixes = ['workspace:', 'npm:'];
+    for (const prefix of protocolPrefixes) {
+        if (version.startsWith(prefix)) {
+            return version.slice(prefix.length);
+        }
+    }
+    return version;
+}
+function isTagVersion(version) {
+    return version === 'latest';
+}
+function getComparableMinVersion(version) {
+    try {
+        return semver.minVersion(version);
+    }
+    catch {
+        return null;
+    }
+}
+function compareVersionSpecs(currentVersion, targetVersion) {
+    const normalizedCurrent = stripProtocolPrefix(currentVersion);
+    const normalizedTarget = stripProtocolPrefix(targetVersion);
+    if (isTagVersion(normalizedCurrent) || isTagVersion(normalizedTarget)) {
+        return 'uncomparable';
+    }
+    if (currentVersion === targetVersion) {
+        return 'same';
+    }
+    if (normalizedCurrent === normalizedTarget) {
+        return 'same';
+    }
+    const currentMin = getComparableMinVersion(normalizedCurrent);
+    const targetMin = getComparableMinVersion(normalizedTarget);
+    if (currentMin && targetMin) {
+        const comparison = semver.compare(currentMin, targetMin);
+        if (comparison > 0) {
+            return 'newer';
+        }
+        if (comparison === 0) {
+            return 'same';
+        }
+        return 'update';
+    }
+    return 'uncomparable';
+}
+function extractCatalog(workspaceContent) {
+    const parsed = yaml.parse(workspaceContent);
+    const catalog = parsed?.catalog;
+    if (!catalog || typeof catalog !== 'object') {
+        throw new Error('catalog section not found in remote pnpm-workspace.yaml');
+    }
+    return catalog;
+}
+function loadJsonFile(filePath) {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+function loadYamlFile(filePath) {
+    return yaml.parse(fs.readFileSync(filePath, 'utf8'));
+}
+function saveYamlFile(filePath, data) {
+    fs.writeFileSync(filePath, yaml.stringify(data), 'utf8');
+}
+function saveJsonFile(filePath, data) {
+    fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+}
+function renderTable(rows, headers) {
+    const widths = [
+        headers[0].length,
+        headers[1].length,
+        headers[2].length,
+        headers[3]?.length ?? 0
+    ];
+    for (const row of rows) {
+        widths[0] = Math.max(widths[0], row.packageName.length);
+        widths[1] = Math.max(widths[1], row.currentVersion.length);
+        widths[2] = Math.max(widths[2], row.targetVersion.length);
+        if ('reason' in row) {
+            widths[3] = Math.max(widths[3], row.reason.length);
+        }
+    }
+    const hasFourthColumn = Boolean(headers[3]);
+    const border = hasFourthColumn
+        ? `┌${'─'.repeat(widths[0] + 2)}┬${'─'.repeat(widths[1] + 2)}┬${'─'.repeat(widths[2] + 2)}┬${'─'.repeat(widths[3] + 2)}┐`
+        : `┌${'─'.repeat(widths[0] + 2)}┬${'─'.repeat(widths[1] + 2)}┬${'─'.repeat(widths[2] + 2)}┐`;
+    const separator = hasFourthColumn
+        ? `├${'─'.repeat(widths[0] + 2)}┼${'─'.repeat(widths[1] + 2)}┼${'─'.repeat(widths[2] + 2)}┼${'─'.repeat(widths[3] + 2)}┤`
+        : `├${'─'.repeat(widths[0] + 2)}┼${'─'.repeat(widths[1] + 2)}┼${'─'.repeat(widths[2] + 2)}┤`;
+    const footer = hasFourthColumn
+        ? `└${'─'.repeat(widths[0] + 2)}┴${'─'.repeat(widths[1] + 2)}┴${'─'.repeat(widths[2] + 2)}┴${'─'.repeat(widths[3] + 2)}┘`
+        : `└${'─'.repeat(widths[0] + 2)}┴${'─'.repeat(widths[1] + 2)}┴${'─'.repeat(widths[2] + 2)}┘`;
+    const formatRow = (columns) => {
+        if (hasFourthColumn) {
+            return `│ ${columns[0].padEnd(widths[0])} │ ${columns[1].padEnd(widths[1])} │ ${columns[2].padEnd(widths[2])} │ ${columns[3].padEnd(widths[3])} │`;
+        }
+        return `│ ${columns[0].padEnd(widths[0])} │ ${columns[1].padEnd(widths[1])} │ ${columns[2].padEnd(widths[2])} │`;
+    };
+    return [
+        border,
+        formatRow(hasFourthColumn ? [headers[0], headers[1], headers[2], headers[3] || ''] : [headers[0], headers[1], headers[2]]),
+        separator,
+        ...rows.map((row) => formatRow('reason' in row
+            ? [row.packageName, row.currentVersion, row.targetVersion, row.reason]
+            : [row.packageName, row.currentVersion, row.targetVersion])),
+        footer
+    ].join('\n');
+}
+function printSkipDetails(skipRows, compactLog) {
+    const newerCount = skipRows.filter((row) => row.reason === 'skipped-newer').length;
+    if (compactLog) {
+        if (newerCount > 0) {
+            console.log(`Skipped ${newerCount} package(s) because local versions are newer than the source.`);
+        }
+        return;
+    }
+    if (skipRows.length === 0) {
+        return;
+    }
+    console.log('\nSkipped:');
+    console.log(renderTable(skipRows, ['Package', 'Before', 'After', 'Reason']));
+}
+async function diaomaoUpdate(config, cwd = typeof process !== 'undefined' ? process.cwd() : '.') {
+    const updateConfig = config.diaomaoUpdate || {};
+    const sourceUrl = updateConfig.sourceUrl || '';
+    const allowedPackages = updateConfig.allowedPackages || [];
+    const compactLog = updateConfig.compactLog !== false;
+    if (!sourceUrl) {
+        throw new Error('diaomaoUpdate.sourceUrl is required');
+    }
+    if (!Array.isArray(allowedPackages) || allowedPackages.length === 0) {
+        throw new Error('diaomaoUpdate.allowedPackages must contain at least one package name');
+    }
+    const packageJsonPath = path.join(cwd, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        throw new Error(`package.json not found in ${cwd}`);
+    }
+    const localWorkspacePath = findNearestFile(cwd, 'pnpm-workspace.yaml');
+    const packageJson = loadJsonFile(packageJsonPath);
+    const localWorkspace = localWorkspacePath ? loadYamlFile(localWorkspacePath) : null;
+    const localCatalog = localWorkspace?.catalog || {};
+    console.log(`Reading update source: ${sourceUrl}`);
+    const remoteWorkspaceContent = await fetchText(sourceUrl);
+    const remoteCatalog = extractCatalog(remoteWorkspaceContent);
+    const updatedRows = [];
+    const skipRows = [];
+    let packageJsonChanged = false;
+    let workspaceChanged = false;
+    for (const packageName of allowedPackages) {
+        const targetVersion = remoteCatalog[packageName];
+        if (!targetVersion) {
+            continue;
+        }
+        let matched = false;
+        for (const section of DEPENDENCY_SECTIONS) {
+            const dependencies = packageJson[section];
+            if (!dependencies || !(packageName in dependencies)) {
+                continue;
+            }
+            matched = true;
+            const currentSpecifier = dependencies[packageName];
+            if (currentSpecifier.startsWith('workspace:')) {
+                skipRows.push({
+                    packageName,
+                    currentVersion: currentSpecifier,
+                    targetVersion,
+                    reason: 'skipped-workspace'
+                });
+                continue;
+            }
+            if (currentSpecifier === 'catalog:') {
+                const localCatalogVersion = localCatalog[packageName];
+                if (!localCatalogVersion) {
+                    skipRows.push({
+                        packageName,
+                        currentVersion: currentSpecifier,
+                        targetVersion,
+                        reason: 'skipped-unresolved-catalog'
+                    });
+                    continue;
+                }
+                const decision = compareVersionSpecs(localCatalogVersion, targetVersion);
+                if (decision === 'newer') {
+                    skipRows.push({
+                        packageName,
+                        currentVersion: localCatalogVersion,
+                        targetVersion,
+                        reason: 'skipped-newer'
+                    });
+                    continue;
+                }
+                if (decision === 'same') {
+                    skipRows.push({
+                        packageName,
+                        currentVersion: localCatalogVersion,
+                        targetVersion,
+                        reason: 'skipped-same'
+                    });
+                    continue;
+                }
+                if (decision === 'uncomparable') {
+                    skipRows.push({
+                        packageName,
+                        currentVersion: localCatalogVersion,
+                        targetVersion,
+                        reason: 'skipped-uncomparable'
+                    });
+                    continue;
+                }
+                localCatalog[packageName] = targetVersion;
+                workspaceChanged = true;
+                updatedRows.push({
+                    packageName,
+                    currentVersion: localCatalogVersion,
+                    targetVersion
+                });
+                continue;
+            }
+            const decision = compareVersionSpecs(currentSpecifier, targetVersion);
+            if (decision === 'newer') {
+                skipRows.push({
+                    packageName,
+                    currentVersion: currentSpecifier,
+                    targetVersion,
+                    reason: 'skipped-newer'
+                });
+                continue;
+            }
+            if (decision === 'same') {
+                skipRows.push({
+                    packageName,
+                    currentVersion: currentSpecifier,
+                    targetVersion,
+                    reason: 'skipped-same'
+                });
+                continue;
+            }
+            if (decision === 'uncomparable') {
+                skipRows.push({
+                    packageName,
+                    currentVersion: currentSpecifier,
+                    targetVersion,
+                    reason: 'skipped-uncomparable'
+                });
+                continue;
+            }
+            dependencies[packageName] = targetVersion;
+            packageJsonChanged = true;
+            updatedRows.push({
+                packageName,
+                currentVersion: currentSpecifier,
+                targetVersion
+            });
+        }
+        if (!matched) {
+            skipRows.push({
+                packageName,
+                currentVersion: '-',
+                targetVersion,
+                reason: 'skipped-missing'
+            });
+        }
+    }
+    if (workspaceChanged && localWorkspacePath && localWorkspace) {
+        localWorkspace.catalog = localCatalog;
+        saveYamlFile(localWorkspacePath, localWorkspace);
+    }
+    if (packageJsonChanged) {
+        saveJsonFile(packageJsonPath, packageJson);
+    }
+    if (updatedRows.length > 0) {
+        console.log('\nResults:');
+        console.log(renderTable(updatedRows, ['Package', 'Before', 'After']));
+    }
+    else {
+        console.log('\nResults:');
+        console.log('No package versions were updated.');
+    }
+    console.log('');
+    console.log(`Updated ${updatedRows.length} package version(s).`);
+    printSkipDetails(skipRows, compactLog);
+    return 0;
+}
+
+exports.diaomaoUpdate = diaomaoUpdate;