@stripchatdev/create-stripchat-extension 0.1.46 → 0.1.48

package/dist/src/migrator/migrations/v2/vite_config_ts/001_turn_off_minify_and_assets_inline.js

@@ -0,0 +1,118 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { IndentationText, NewLineKind, Node, Project, SyntaxKind } from 'ts-morph';
+import { VITE_CONFIG_REL_PATH_BY_LANGUAGE } from '../../../../constants.js';
+const resolveConfigObject = (sourceText, fileName) => {
+    const project = new Project({
+        manipulationSettings: {
+            indentationText: IndentationText.TwoSpaces,
+            newLineKind: NewLineKind.LineFeed,
+        },
+        useInMemoryFileSystem: true,
+    });
+    const sourceFile = project.createSourceFile(fileName, sourceText, { overwrite: true });
+    const exportAssignment = sourceFile.getExportAssignment(() => true);
+    if (!exportAssignment || exportAssignment.isExportEquals()) {
+        return null;
+    }
+    const expression = exportAssignment.getExpression();
+    if (!expression) {
+        return null;
+    }
+    if (Node.isObjectLiteralExpression(expression)) {
+        return { sourceFile, configObject: expression };
+    }
+    if (!Node.isCallExpression(expression)) {
+        return null;
+    }
+    const firstArg = expression.getArguments()[0];
+    if (!firstArg || !Node.isObjectLiteralExpression(firstArg)) {
+        return null;
+    }
+    return { sourceFile, configObject: firstArg };
+};
+const withTurnedOffMinifyAndAssetsInline = (viteConfigContent, fileName) => {
+    const resolved = resolveConfigObject(viteConfigContent, fileName);
+    if (!resolved) {
+        return viteConfigContent;
+    }
+    const { configObject, sourceFile } = resolved;
+    const buildProperty = configObject.getProperty('build');
+    if (!buildProperty || !Node.isPropertyAssignment(buildProperty)) {
+        return viteConfigContent;
+    }
+    const buildObject = buildProperty.getInitializerIfKind(SyntaxKind.ObjectLiteralExpression);
+    if (!buildObject) {
+        return viteConfigContent;
+    }
+    const minifyProperty = buildObject.getProperty('minify');
+    const assetsInlineLimitProperty = buildObject.getProperty('assetsInlineLimit');
+    let isPresetMinify = false;
+    let isPresentAssetsInlineLimit = false;
+    if (minifyProperty && Node.isPropertyAssignment(minifyProperty)) {
+        minifyProperty.setInitializer('false');
+        isPresetMinify = true;
+    }
+    if (assetsInlineLimitProperty && Node.isPropertyAssignment(assetsInlineLimitProperty)) {
+        assetsInlineLimitProperty.setInitializer('0');
+        isPresentAssetsInlineLimit = true;
+    }
+    const properties = buildObject.getProperties();
+    const outDirProperty = properties.find((property) => Node.isPropertyAssignment(property) && property.getName() === 'outDir');
+    const rollupProperty = properties.find((property) => Node.isPropertyAssignment(property) && property.getName() === 'rollupOptions');
+    const outDirIndex = outDirProperty ? properties.indexOf(outDirProperty) : -1;
+    const rollupIndex = rollupProperty ? properties.indexOf(rollupProperty) : -1;
+    let currInsertIndex = rollupIndex >= 0
+        ? rollupIndex
+        : outDirIndex >= 0
+            ? outDirIndex + 1
+            : properties.length;
+    if (!isPresetMinify) {
+        buildObject.insertPropertyAssignment(currInsertIndex, {
+            name: 'minify',
+            initializer: 'false',
+        });
+        currInsertIndex += 1;
+    }
+    if (!isPresentAssetsInlineLimit) {
+        buildObject.insertPropertyAssignment(currInsertIndex, {
+            name: 'assetsInlineLimit',
+            initializer: '0',
+        });
+    }
+    sourceFile.formatText({
+        convertTabsToSpaces: true,
+        indentSize: 2,
+    });
+    return sourceFile.getFullText();
+};
+export const up = (ctx) => {
+    const viteConfigRelPath = VITE_CONFIG_REL_PATH_BY_LANGUAGE[ctx.targetProjectConfig.language];
+    const targetViteConfigPath = join(ctx.projectDir, viteConfigRelPath);
+    const generatedViteConfigPath = join(ctx.generatedProjectDir, viteConfigRelPath);
+    if (!existsSync(targetViteConfigPath)) {
+        mkdirSync(dirname(targetViteConfigPath), { recursive: true });
+        copyFileSync(generatedViteConfigPath, targetViteConfigPath);
+        return [
+            {
+                filePath: targetViteConfigPath,
+                relFilePath: viteConfigRelPath,
+            },
+        ];
+    }
+    const targetViteConfigContent = readFileSync(targetViteConfigPath, 'utf8');
+    const mergedViteConfigContent = withTurnedOffMinifyAndAssetsInline(targetViteConfigContent, viteConfigRelPath);
+    if (targetViteConfigContent === mergedViteConfigContent) {
+        return [];
+    }
+    writeFileSync(targetViteConfigPath, mergedViteConfigContent, {
+        encoding: 'utf8',
+        flag: 'w',
+    });
+    return [
+        {
+            filePath: targetViteConfigPath,
+            relFilePath: viteConfigRelPath,
+        },
+    ];
+};

package/dist/src/migrator/planner.d.ts

@@ -0,0 +1,5 @@
+import type { TManagedFile } from '../templates/types';
+import type { TProjectConfig } from '../types';
+import type { TMigrationExecutionPlan, TMigrationPlan } from './types';
+export declare const planMigrations: (targetManagedFiles: TManagedFile[], managedFiles: TManagedFile[], lastTemplateVersion: number) => TMigrationPlan[];
+export declare const planMigrationExecution: (targetProjectConfig: TProjectConfig, templateVersion: number) => TMigrationExecutionPlan;

package/dist/src/migrator/planner.js

@@ -0,0 +1,65 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { updateProjectConfig } from '../projectConfig/updateProjectConfig.js';
+import { INIT_TEMPLATE_VERSION } from '../templates/constants.js';
+import { getTemplateMigrationsDir } from './migration.js';
+const discoverMigrationsByVersion = (type, relPath, version) => {
+    const migrationsDir = getTemplateMigrationsDir(type, version, relPath);
+    if (!existsSync(migrationsDir)) {
+        return [];
+    }
+    const entries = readdirSync(migrationsDir, { withFileTypes: true });
+    return entries
+        .filter((entry) => {
+        return entry.isFile() && !entry.name.endsWith('.d.ts');
+    })
+        .map((entry) => {
+        const scriptPath = join(entry.parentPath, entry.name);
+        const migrationPlan = {
+            scriptPath,
+            templateRelPath: relPath,
+            templateVersion: version,
+        };
+        return migrationPlan;
+    })
+        .sort((a, b) => {
+        return a.scriptPath.localeCompare(b.scriptPath);
+    });
+};
+const discoverMigrationsForTemplate = (templateFileRelPath, fromVersion, toVersion) => {
+    const templateMigrations = [];
+    let iterVersion = fromVersion;
+    while (iterVersion <= toVersion) {
+        if (iterVersion > fromVersion) {
+            const versionMigrations = discoverMigrationsByVersion('migrations', templateFileRelPath, iterVersion);
+            templateMigrations.push(...versionMigrations);
+        }
+        const versionUpdates = discoverMigrationsByVersion('updates', templateFileRelPath, iterVersion);
+        templateMigrations.push(...versionUpdates);
+        iterVersion++;
+    }
+    return templateMigrations;
+};
+export const planMigrations = (targetManagedFiles, managedFiles, lastTemplateVersion) => {
+    const targetManagedFilesMap = {};
+    targetManagedFiles.forEach((file) => {
+        targetManagedFilesMap[file.relPath] = file;
+    });
+    const allMigrations = [];
+    for (const managedFile of managedFiles) {
+        const targetManagedFile = targetManagedFilesMap[managedFile.relPath];
+        const targetVersion = targetManagedFile ? targetManagedFile.version : INIT_TEMPLATE_VERSION;
+        const templateMigrations = discoverMigrationsForTemplate(managedFile.relPath, targetVersion, lastTemplateVersion);
+        allMigrations.push(...templateMigrations);
+    }
+    return allMigrations;
+};
+export const planMigrationExecution = (targetProjectConfig, templateVersion) => {
+    const updatedProjectConfig = updateProjectConfig(templateVersion, targetProjectConfig);
+    const migrationPlans = planMigrations(targetProjectConfig.managedFiles, updatedProjectConfig.managedFiles, updatedProjectConfig.lastTemplateVersion);
+    return {
+        migrationPlans,
+        targetProjectConfig,
+        updatedProjectConfig,
+    };
+};

package/dist/src/migrator/planner.test.js

@@ -0,0 +1,40 @@
+import { dirname, relative } from 'node:path';
+import { normalizePath } from 'vite';
+import { describe, expect, it } from 'vitest';
+import { INIT_TEMPLATE_VERSION, MANAGED_TEMPLATES, } from '../templates/constants.js';
+import { collectManagedFiles, LAST_TEMPLATE_VERSION, TEMPLATES_DIR } from '../templates/templates.js';
+import { planMigrations } from './planner.js';
+const buildTestCases = () => {
+    const testCases = [];
+    let fromVersion = INIT_TEMPLATE_VERSION;
+    const lastVersion = LAST_TEMPLATE_VERSION;
+    while (fromVersion <= lastVersion) {
+        const testCase = {
+            fromVersion,
+            lastVersion,
+            targetManagedFiles: collectManagedFiles(TEMPLATES_DIR, MANAGED_TEMPLATES, fromVersion),
+            managedFiles: collectManagedFiles(TEMPLATES_DIR, MANAGED_TEMPLATES, lastVersion),
+        };
+        testCases.push(testCase);
+        fromVersion++;
+    }
+    return testCases;
+};
+const normalizeMigrationPlans = (migrationPlans) => {
+    return migrationPlans.map((migrationPlan) => {
+        const scriptPathResl = normalizePath(relative(dirname(TEMPLATES_DIR), migrationPlan.scriptPath));
+        return {
+            type: 'script',
+            scriptPath: scriptPathResl,
+            templateRelPath: normalizePath(migrationPlan.templateRelPath),
+            templateVersion: migrationPlan.templateVersion,
+        };
+    });
+};
+const TEST_CASES = buildTestCases();
+describe('planMigrations', { tags: ['snapshot'] }, () => {
+    it.each(TEST_CASES)('from version $fromVersion to last version $lastVersion', ({ lastVersion, managedFiles, targetManagedFiles }) => {
+        const migrationPlans = planMigrations(targetManagedFiles, managedFiles, lastVersion);
+        expect(normalizeMigrationPlans(migrationPlans)).toMatchSnapshot();
+    });
+});

package/dist/src/migrator/types.d.ts

@@ -0,0 +1,29 @@
+import type { TProjectConfig } from '../types.js';
+export type TMigrationContext = {
+    generatedProjectDir: string;
+    projectDir: string;
+    targetProjectConfig: TProjectConfig;
+    templateVersion: number;
+    updatedProjectConfig: TProjectConfig;
+};
+export type TMigrationChange = {
+    filePath: string;
+    relFilePath: string;
+};
+export type TMigrationPlan = {
+    scriptPath: string;
+    templateRelPath: string;
+    templateVersion: number;
+};
+export type TMigrationExecutionPlan = {
+    migrationPlans: TMigrationPlan[];
+    targetProjectConfig: TProjectConfig;
+    updatedProjectConfig: TProjectConfig;
+};
+export type TMigration = {
+    up(ctx: TMigrationContext): TMigrationChange[];
+};
+export type TMigrationDiff = {
+    diff: string;
+    filePath: string;
+};

package/dist/src/migrator/updates/updates.test.js

@@ -0,0 +1,102 @@
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { CLI_COMMANDS_MAP, EXT_HELPER_VERSION } from '../../constants.js';
+import { toNormalizedRelPath } from '../../helpers/normalizePath.js';
+import { buildProjectConfig } from '../../projectConfig/buildProjectConfig.js';
+import { executeCommands } from '../../templater/executor.js';
+import { mapProjectConfigToTemplateData } from '../../templater/mappers/mapProjectConfigToTemplateModel.js';
+import { planProject } from '../../templater/planner.js';
+import { MANAGED_TEMPLATES } from '../../templates/constants.js';
+import { collectManagedFiles, discoverVersionDirs, LAST_TEMPLATE_VERSION, TEMPLATES_DIR, } from '../../templates/templates.js';
+import { executeMigrations } from '../executor.js';
+import { planMigrationExecution } from '../planner.js';
+const testBuildProjectConfigOptions = {
+    category: 'games-and-fun',
+    framework: 'preact',
+    lastTemplateVersion: LAST_TEMPLATE_VERSION,
+    cliCommands: {
+        cli: 'old-cli-command',
+        'cli:update': 'old-update-command',
+    },
+    managedTemplates: MANAGED_TEMPLATES,
+    templatesDir: TEMPLATES_DIR,
+    name: 'test',
+    slots: ['EXTENSION_SLOT_MAIN_GAME_FUN', 'EXTENSION_SLOT_BACKGROUND'],
+    extHelperVersion: EXT_HELPER_VERSION,
+    language: 'ts',
+    packageManager: 'npm',
+};
+const compareManagedFiles = (targetProjectDir, referenceProjectDir, templateVersion, migrationPlans) => {
+    const managedFiles = collectManagedFiles(TEMPLATES_DIR, MANAGED_TEMPLATES, templateVersion);
+    const diffFileRelPaths = [];
+    const migrationPlansFilesSet = new Set();
+    migrationPlans.forEach((migrationPlan) => {
+        migrationPlansFilesSet.add(migrationPlan.templateRelPath);
+    });
+    for (const managedFile of managedFiles) {
+        if (!migrationPlansFilesSet.has(managedFile.relPath)) {
+            continue;
+        }
+        const targetFileContent = readFileSync(join(targetProjectDir, managedFile.relPath), 'utf8');
+        const referenceFileContent = readFileSync(join(referenceProjectDir, managedFile.relPath), 'utf8');
+        if (targetFileContent !== referenceFileContent) {
+            diffFileRelPaths.push(managedFile.relPath);
+        }
+    }
+    return diffFileRelPaths;
+};
+describe('updates', () => {
+    const versionDirs = discoverVersionDirs(TEMPLATES_DIR, LAST_TEMPLATE_VERSION, 'asc');
+    for (const versionDir of versionDirs) {
+        const templateVersion = versionDir.version;
+        it(`runs updates for v${templateVersion}`, async () => {
+            const targetProjectDir = mkdtempSync(join(tmpdir(), 'sce-test-target-project-dir'));
+            const referenceProjectDir = mkdtempSync(join(tmpdir(), 'sce-test-reference-project-dir'));
+            try {
+                const targetProjectConfig = buildProjectConfig({
+                    ...testBuildProjectConfigOptions,
+                    lastTemplateVersion: templateVersion,
+                });
+                const targetTemplateData = mapProjectConfigToTemplateData(targetProjectConfig);
+                const targetCommands = planProject(targetProjectDir, templateVersion, targetTemplateData);
+                executeCommands(targetCommands);
+                const referenceProjectConfig = buildProjectConfig({
+                    ...testBuildProjectConfigOptions,
+                    cliCommands: CLI_COMMANDS_MAP,
+                    lastTemplateVersion: templateVersion,
+                });
+                const referenceTemplateData = mapProjectConfigToTemplateData({
+                    ...referenceProjectConfig,
+                    lastTemplateVersion: templateVersion,
+                });
+                const referenceCommands = planProject(referenceProjectDir, templateVersion, referenceTemplateData);
+                executeCommands(referenceCommands);
+                const executionPlan = planMigrationExecution(targetProjectConfig, templateVersion);
+                await executeMigrations({
+                    projectDir: targetProjectDir,
+                    executionPlan,
+                    isDryRun: false,
+                });
+                const isOnlyUpdates = executionPlan.migrationPlans.every((migrationPlan) => {
+                    return toNormalizedRelPath(migrationPlan.scriptPath).includes('/updates/');
+                });
+                expect(isOnlyUpdates).toBe(true);
+                const result = compareManagedFiles(targetProjectDir, referenceProjectDir, templateVersion, executionPlan.migrationPlans);
+                expect(result).toEqual([]);
+                const idempotentExecutionPlan = planMigrationExecution(targetProjectConfig, templateVersion);
+                const idempotentResult = await executeMigrations({
+                    projectDir: targetProjectDir,
+                    executionPlan: idempotentExecutionPlan,
+                    isDryRun: false,
+                });
+                expect(idempotentResult).toEqual([]);
+            }
+            finally {
+                rmSync(targetProjectDir, { recursive: true, force: true });
+                rmSync(referenceProjectDir, { recursive: true, force: true });
+            }
+        });
+    }
+});

package/dist/src/migrator/updates/v2/AGENTS_md/001_update-generated-part.d.ts

@@ -0,0 +1,2 @@
+import type { TMigrationChange, TMigrationContext } from '../../../types.js';
+export declare const up: (ctx: TMigrationContext) => TMigrationChange[];

package/dist/src/migrator/updates/v2/AGENTS_md/001_update-generated-part.js

@@ -0,0 +1,38 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { AGENTS_MD_REL_PATH, AGENTS_TEMPLATE_END, AGENTS_TEMPLATE_START } from '../../../../constants.js';
+const agentsReplaceRegexp = new RegExp(`${AGENTS_TEMPLATE_START}[\\s\\S]*${AGENTS_TEMPLATE_END}`);
+export const up = (ctx) => {
+    const targetAgentsFilePath = join(ctx.projectDir, AGENTS_MD_REL_PATH);
+    const generatedAgentsPath = join(ctx.generatedProjectDir, AGENTS_MD_REL_PATH);
+    const generatedAgentsContent = readFileSync(generatedAgentsPath, 'utf8');
+    if (!existsSync(targetAgentsFilePath)) {
+        mkdirSync(dirname(targetAgentsFilePath), { recursive: true });
+        copyFileSync(generatedAgentsPath, targetAgentsFilePath);
+        return [
+            {
+                filePath: targetAgentsFilePath,
+                relFilePath: AGENTS_MD_REL_PATH,
+            },
+        ];
+    }
+    const targetAgentsContent = readFileSync(targetAgentsFilePath, 'utf8');
+    const generatedTrimmedContent = generatedAgentsContent.trim();
+    const hasGeneratedMarkers = agentsReplaceRegexp.test(targetAgentsContent);
+    const newAgentsContent = hasGeneratedMarkers
+        ? targetAgentsContent.replace(agentsReplaceRegexp, generatedTrimmedContent)
+        : `${generatedTrimmedContent}\n\n${targetAgentsContent}`;
+    if (newAgentsContent === targetAgentsContent) {
+        return [];
+    }
+    writeFileSync(targetAgentsFilePath, newAgentsContent, {
+        encoding: 'utf8',
+        flag: 'w',
+    });
+    return [
+        {
+            filePath: targetAgentsFilePath,
+            relFilePath: AGENTS_MD_REL_PATH,
+        },
+    ];
+};

package/dist/src/migrator/updates/v2/package_json/001_update-versions.d.ts

@@ -0,0 +1,2 @@
+import type { TMigrationChange, TMigrationContext } from '../../../types.js';
+export declare const up: (ctx: TMigrationContext) => TMigrationChange[];

package/dist/src/migrator/updates/v2/package_json/001_update-versions.js

@@ -0,0 +1,77 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { PACKAGE_JSON_REL_PATH } from '../../../../constants.js';
+import { AppError } from '../../../../helpers/error.js';
+const resolvePackageJson = (packageJsonPath) => {
+    const packageJsonContent = readFileSync(packageJsonPath, 'utf8');
+    let packageJson;
+    try {
+        packageJson = JSON.parse(packageJsonContent);
+    }
+    catch {
+        throw new AppError(`Failed to parse package json: ${packageJsonPath}`);
+    }
+    return {
+        packageJson,
+        packageJsonContent,
+    };
+};
+const updateDependencies = (packageJson, newProjectConfig) => {
+    const { dependencies, devDependencies } = newProjectConfig;
+    const newPackageJson = structuredClone(packageJson);
+    if (!newPackageJson.dependencies) {
+        newPackageJson.dependencies = {};
+    }
+    for (const packageName in dependencies) {
+        const packageVersion = dependencies[packageName];
+        if (!packageVersion) {
+            continue;
+        }
+        if (newPackageJson.dependencies[packageName] !== packageVersion) {
+            newPackageJson.dependencies[packageName] = packageVersion;
+        }
+    }
+    if (!newPackageJson.devDependencies) {
+        newPackageJson.devDependencies = {};
+    }
+    for (const packageName in devDependencies) {
+        const packageVersion = devDependencies[packageName];
+        if (!packageVersion) {
+            continue;
+        }
+        if (newPackageJson.devDependencies[packageName] !== packageVersion) {
+            newPackageJson.devDependencies[packageName] = packageVersion;
+        }
+    }
+    return newPackageJson;
+};
+export const up = (ctx) => {
+    const targetPackageJsonPath = join(ctx.projectDir, PACKAGE_JSON_REL_PATH);
+    const generatedPackageJsonPath = join(ctx.generatedProjectDir, PACKAGE_JSON_REL_PATH);
+    if (!existsSync(targetPackageJsonPath)) {
+        mkdirSync(dirname(targetPackageJsonPath), { recursive: true });
+        copyFileSync(generatedPackageJsonPath, targetPackageJsonPath);
+        return [
+            {
+                filePath: targetPackageJsonPath,
+                relFilePath: PACKAGE_JSON_REL_PATH,
+            },
+        ];
+    }
+    const { packageJson, packageJsonContent } = resolvePackageJson(targetPackageJsonPath);
+    const updatedPackageJson = updateDependencies(packageJson, ctx.updatedProjectConfig);
+    const newPackageJsonContent = `${JSON.stringify(updatedPackageJson, null, 2)}\n`;
+    if (newPackageJsonContent === packageJsonContent) {
+        return [];
+    }
+    writeFileSync(targetPackageJsonPath, newPackageJsonContent, {
+        encoding: 'utf8',
+        flag: 'w',
+    });
+    return [
+        {
+            filePath: targetPackageJsonPath,
+            relFilePath: PACKAGE_JSON_REL_PATH,
+        },
+    ];
+};

package/dist/src/migrator/updates/v2/package_json/002_add-cli-commands.d.ts

@@ -0,0 +1,2 @@
+import type { TMigrationChange, TMigrationContext } from '../../../types.js';
+export declare const up: (ctx: TMigrationContext) => TMigrationChange[];

package/dist/src/migrator/updates/v2/package_json/002_add-cli-commands.js

@@ -0,0 +1,61 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { PACKAGE_JSON_REL_PATH } from '../../../../constants.js';
+import { AppError } from '../../../../helpers/error.js';
+const resolvePackageJson = (packageJsonPath) => {
+    const packageJsonContent = readFileSync(packageJsonPath, 'utf8');
+    let packageJson;
+    try {
+        packageJson = JSON.parse(packageJsonContent);
+    }
+    catch {
+        throw new AppError(`Failed to parse package json: ${packageJsonPath}`);
+    }
+    return {
+        packageJson,
+        packageJsonContent,
+    };
+};
+const updateCliCommands = (packageJson, projectConfig, newProjectConfig) => {
+    const newPackageJson = structuredClone(packageJson);
+    if (!newPackageJson.scripts) {
+        throw new AppError('Section scripts in package.json not found');
+    }
+    for (const commandName in projectConfig.cliCommands) {
+        delete newPackageJson.scripts[commandName];
+    }
+    for (const commandName in newProjectConfig.cliCommands) {
+        newPackageJson.scripts[commandName] = newProjectConfig.cliCommands[commandName];
+    }
+    return newPackageJson;
+};
+export const up = (ctx) => {
+    const targetPackageJsonPath = join(ctx.projectDir, PACKAGE_JSON_REL_PATH);
+    const generatedPackageJsonPath = join(ctx.generatedProjectDir, PACKAGE_JSON_REL_PATH);
+    if (!existsSync(targetPackageJsonPath)) {
+        mkdirSync(dirname(targetPackageJsonPath), { recursive: true });
+        copyFileSync(generatedPackageJsonPath, targetPackageJsonPath);
+        return [
+            {
+                filePath: targetPackageJsonPath,
+                relFilePath: PACKAGE_JSON_REL_PATH,
+            },
+        ];
+    }
+    const { packageJson, packageJsonContent } = resolvePackageJson(targetPackageJsonPath);
+    const newPackageJson = updateCliCommands(packageJson, ctx.targetProjectConfig, ctx.updatedProjectConfig);
+    const newPackageJsonContent = `${JSON.stringify(newPackageJson, null, 2)}\n`;
+    if (newPackageJsonContent === packageJsonContent) {
+        return [];
+    }
+    writeFileSync(targetPackageJsonPath, newPackageJsonContent, {
+        encoding: 'utf8',
+        flag: 'w',
+    });
+    return [
+        {
+            filePath: targetPackageJsonPath,
+            relFilePath: PACKAGE_JSON_REL_PATH,
+        },
+    ];
+};

package/dist/src/migrator/validators/getIsValidMigration.d.ts

@@ -0,0 +1,2 @@
+import type { TMigration } from '../types';
+export declare const getIsValidMigration: (value: unknown) => value is TMigration;

package/dist/src/migrator/validators/getIsValidMigration.js

@@ -0,0 +1,3 @@
+export const getIsValidMigration = (value) => {
+    return typeof value === 'object' && value !== null && 'up' in value && typeof value.up === 'function';
+};

package/dist/src/migrator/validators/getIsValidMigration.test.js

@@ -0,0 +1,13 @@
+import { describe, expect, it } from 'vitest';
+import { getIsValidMigration } from './getIsValidMigration.js';
+describe('getIsValidMigration', () => {
+    it('returns true for migration-like object with up function', () => {
+        const value = {
+            up: () => [],
+        };
+        expect(getIsValidMigration(value)).toBe(true);
+    });
+    it.each([null, undefined, 42, 'migration', true, {}, { up: 1 }, { up: 'fn' }, { up: null }])('returns false for invalid migration shape: %p', (value) => {
+        expect(getIsValidMigration(value)).toBe(false);
+    });
+});

package/dist/src/projectConfig/buildProjectConfig.d.ts

@@ -0,0 +1,15 @@
+import type { TCategory, TCliCommandsMap, TFramework, TLanguage, TPackageManager, TProjectConfig, TRelPath, TSlot } from '../types.js';
+export type TBuildProjectConfigOptions = {
+    category: TCategory;
+    cliCommands: TCliCommandsMap;
+    extHelperVersion: string;
+    framework: TFramework;
+    language: TLanguage;
+    lastTemplateVersion: number;
+    managedTemplates: TRelPath[];
+    name: string;
+    packageManager: TPackageManager;
+    slots: TSlot[];
+    templatesDir: string;
+};
+export declare const buildProjectConfig: (options: TBuildProjectConfigOptions) => TProjectConfig;

package/dist/src/projectConfig/buildProjectConfig.js

@@ -0,0 +1,27 @@
+import { resolveDependencies } from '../dependencies/resolveDependencies.js';
+import { toNormalizedRelPath } from '../helpers/normalizePath.js';
+import { collectManagedFiles, TEMPLATES_DIR } from '../templates/templates.js';
+export const buildProjectConfig = (options) => {
+    const { category, cliCommands, extHelperVersion, framework, language, lastTemplateVersion, managedTemplates, name, packageManager, slots, } = options;
+    const { dependencies, devDependencies } = resolveDependencies(language, framework);
+    const managedFiles = collectManagedFiles(TEMPLATES_DIR, managedTemplates, lastTemplateVersion).map((file) => {
+        return {
+            ...file,
+            relPath: toNormalizedRelPath(file.relPath),
+        };
+    });
+    return {
+        lastTemplateVersion,
+        name,
+        category,
+        language,
+        framework,
+        packageManager,
+        dependencies,
+        devDependencies,
+        slots,
+        cliCommands,
+        managedFiles: managedFiles,
+        extHelperVersion,
+    };
+};

package/dist/src/projectConfig/detectPackageManagerRuntime.d.ts

@@ -0,0 +1,2 @@
+import type { TPackageManager } from '../types.js';
+export declare const detectPackageManagerRuntime: () => TPackageManager;

package/dist/src/{helpers/detectPackageManager.js → projectConfig/detectPackageManagerRuntime.js}

@@ -1,4 +1,4 @@
-export const detectPackageManager = () => {
+export const detectPackageManagerRuntime = () => {
     if ('Bun' in globalThis || process?.versions?.bun)
         return 'bun';
     const ua = process.env.npm_config_user_agent;