@stripchatdev/create-stripchat-extension 0.1.45 → 0.1.47

package/dist/src/helpers/error.js

@@ -0,0 +1,9 @@
+export class AppError extends Error {
+    constructor(message, cause) {
+        super(message, {
+            cause,
+        });
+        this.name = this.constructor.name;
+        Error.captureStackTrace(this, this.constructor);
+    }
+}

package/dist/src/helpers/error.test.js

@@ -0,0 +1,15 @@
+import { describe, expect, it } from 'vitest';
+import { AppError } from './error.js';
+describe('AppError', () => {
+    it('create error with message, cause, stack and constructor name', () => {
+        const appErrorMessage = 'some application error';
+        const causeError = new Error('path does not exists');
+        const appError = new AppError('some application error', causeError);
+        expect(appError).instanceOf(Error);
+        expect(appError).instanceOf(AppError);
+        expect(appError.message).toBe(appErrorMessage);
+        expect(appError.cause).toBe(causeError);
+        expect(appError.name).toBe(AppError.name);
+        expect(appError.stack).toBeDefined();
+    });
+});

package/dist/src/helpers/getIsDirectoryExists.d.ts

@@ -0,0 +1,7 @@
+export declare const getIsDirectoryExists: (dirPath: string) => {
+    error: null;
+    isExists: true;
+} | {
+    error: string;
+    isExists: false;
+};

package/dist/src/helpers/getIsDirectoryExists.js

@@ -0,0 +1,23 @@
+import { statSync } from 'node:fs';
+export const getIsDirectoryExists = (dirPath) => {
+    let stat;
+    try {
+        stat = statSync(dirPath);
+    }
+    catch {
+        return {
+            isExists: false,
+            error: `Path does not exists: ${dirPath}`,
+        };
+    }
+    if (!stat.isDirectory()) {
+        return {
+            isExists: false,
+            error: `Path is not a directory: ${dirPath}`,
+        };
+    }
+    return {
+        isExists: true,
+        error: null,
+    };
+};

package/dist/src/helpers/getIsDirectoryExists.test.js

@@ -0,0 +1,34 @@
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { describe, it, expect, afterAll, beforeAll } from 'vitest';
+import { getIsDirectoryExists } from './getIsDirectoryExists.js';
+describe('getIsDirectoryExists', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'sce-getIsDirectoryExists-'));
+    const filePath = join(dir, 'test.txt');
+    beforeAll(() => {
+        writeFileSync(filePath, 'Hello, World!', {
+            encoding: 'utf8',
+        });
+    });
+    afterAll(() => {
+        rmSync(dir, { recursive: true, force: true });
+    });
+    it('exists if checking path is dir', () => {
+        expect(getIsDirectoryExists(dir)).toEqual({
+            error: null,
+            isExists: true,
+        });
+    });
+    it('not exists is checking path is file', () => {
+        const { error, isExists } = getIsDirectoryExists(filePath);
+        expect(isExists).toBe(false);
+        expect(error).toBe(`Path is not a directory: ${filePath}`);
+    });
+    it('not exists is checking not exists path', () => {
+        const notExistsPath = join(dir, '/some/not-exists/path');
+        const { error, isExists } = getIsDirectoryExists(notExistsPath);
+        expect(isExists).toBe(false);
+        expect(error).toBe(`Path does not exists: ${notExistsPath}`);
+    });
+});

package/dist/src/helpers/getIsJsxFramework.d.ts

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

package/dist/src/helpers/getIsJsxFramework.js

@@ -0,0 +1,2 @@
+import { JSX_FRAMEWORKS } from '../constants.js';
+export const getIsJsxFramework = (framework) => JSX_FRAMEWORKS.includes(framework);

package/dist/src/helpers/getIsJsxFramework.test.js

@@ -0,0 +1,10 @@
+import { describe, expect, it } from 'vitest';
+import { getIsJsxFramework } from './getIsJsxFramework.js';
+describe('getIsJsxFramework', () => {
+    it.each(['preact'])('returns true for jsx framework: %s', (framework) => {
+        expect(getIsJsxFramework(framework)).toBe(true);
+    });
+    it.each(['vanilla'])('returns false for non jsx framework: %s', (framework) => {
+        expect(getIsJsxFramework(framework)).toBe(false);
+    });
+});

package/dist/src/helpers/getIsTypescript.d.ts

@@ -0,0 +1,2 @@
+import type { TLanguage } from '../types.js';
+export declare const getIsTypescript: (language: TLanguage) => language is "ts";

package/dist/src/helpers/getIsTypescript.js

@@ -0,0 +1 @@
+export const getIsTypescript = (language) => language === 'ts';

package/dist/src/helpers/getIsTypescript.test.js

@@ -0,0 +1,10 @@
+import { describe, it, expect } from 'vitest';
+import { getIsTypescript } from './getIsTypescript.js';
+describe('getIsTypescript', () => {
+    it('return true for typescript language', () => {
+        expect(getIsTypescript('ts')).toBe(true);
+    });
+    it.each(['js'])('return false for non typescript language', (lang) => {
+        expect(getIsTypescript(lang)).toBe(false);
+    });
+});

package/dist/src/helpers/isSubPath.d.ts

@@ -0,0 +1 @@
+export declare const isSubPath: (parentPath: string, childPath: string) => boolean;

package/dist/src/helpers/isSubPath.js

@@ -0,0 +1,5 @@
+import { relative, sep } from 'node:path';
+export const isSubPath = (parentPath, childPath) => {
+    const relPath = relative(parentPath, childPath);
+    return relPath.length > 0 && !relPath.startsWith(`..${sep}`) && relPath !== '..';
+};

package/dist/src/helpers/normalizePath.d.ts

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

package/dist/src/helpers/normalizePath.js

@@ -0,0 +1,4 @@
+const normalizePath = (pathValue) => pathValue.replaceAll('\\', '/');
+export const toNormalizedRelPath = (relPath) => {
+    return normalizePath(relPath);
+};

package/dist/src/helpers/normalizePath.test.js

@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest';
+import { toNormalizedRelPath } from './normalizePath.js';
+describe('normalizePath', () => {
+    it('replaces backslashes with forward slashes', () => {
+        expect(toNormalizedRelPath('src\\slots\\main')).toBe('src/slots/main');
+    });
+    it('replaces multiple backslashes', () => {
+        expect(toNormalizedRelPath('a\\b\\c\\d')).toBe('a/b/c/d');
+    });
+    it('leaves forward slashes unchanged', () => {
+        expect(toNormalizedRelPath('src/slots/main')).toBe('src/slots/main');
+    });
+    it('handles mixed separators', () => {
+        expect(toNormalizedRelPath('src\\slots/main\\file.ts')).toBe('src/slots/main/file.ts');
+    });
+    it('returns empty string unchanged', () => {
+        expect(toNormalizedRelPath('')).toBe('');
+    });
+});

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

@@ -0,0 +1,9 @@
+import type { TMigrationDiff, TMigrationExecutionPlan } from './types.js';
+export type TExecuteMigrationsOptions = {
+    executionPlan: TMigrationExecutionPlan;
+    isDryRun: boolean;
+    onCommitChange?: (file: string, previewFile: string) => void;
+    projectDir: string;
+    verbose?: boolean;
+};
+export declare const executeMigrations: (options: TExecuteMigrationsOptions) => Promise<TMigrationDiff[]>;

package/dist/src/migrator/executor.js

@@ -0,0 +1,112 @@
+import { createPatch } from 'diff';
+import { mkdtempSync, readFileSync, rmSync, copyFileSync, existsSync, cpSync, mkdirSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { dirname, join, relative } from 'node:path';
+import { executeCommands } from '../templater/executor.js';
+import { mapProjectConfigToTemplateData } from '../templater/mappers/mapProjectConfigToTemplateModel.js';
+import { planProject } from '../templater/planner.js';
+import { executeMigration, } from './migration.js';
+const generateProject = (projectConfig, targetVersion) => {
+    const generatedProjectDir = mkdtempSync(join(tmpdir(), 'sce-generated-'));
+    const templateData = mapProjectConfigToTemplateData(projectConfig);
+    const commands = planProject(generatedProjectDir, targetVersion, templateData);
+    executeCommands(commands);
+    return generatedProjectDir;
+};
+const createProjectModifiedPreview = (projectDir, managedFiles) => {
+    const previewProjectDir = mkdtempSync(join(tmpdir(), 'sce-preview-'));
+    const managedFilesMap = {};
+    managedFiles.forEach((managedFile) => {
+        if (!managedFile.deleted) {
+            managedFilesMap[managedFile.relPath] = true;
+        }
+    });
+    for (const managedFile of managedFiles) {
+        if (managedFile.deleted) {
+            continue;
+        }
+        const srcPath = join(projectDir, managedFile.relPath);
+        if (existsSync(srcPath)) {
+            cpSync(srcPath, join(previewProjectDir, managedFile.relPath));
+        }
+    }
+    return previewProjectDir;
+};
+const getChangeDiff = (projectDir, file, previewFile) => {
+    if (!existsSync(previewFile)) {
+        if (!existsSync(file)) {
+            return null;
+        }
+        const targetFileContent = readFileSync(file, 'utf8');
+        return createPatch(relative(projectDir, file), targetFileContent, '');
+    }
+    if (!existsSync(file)) {
+        const newFileContent = readFileSync(previewFile, 'utf8');
+        return createPatch(relative(projectDir, file), '', newFileContent);
+    }
+    const fileContent = readFileSync(file, 'utf8');
+    const newFileContent = readFileSync(previewFile, 'utf8');
+    if (fileContent === newFileContent) {
+        return null;
+    }
+    return createPatch(relative(projectDir, file), fileContent, newFileContent);
+};
+const commitChange = (file, previewFile) => {
+    const isPreviewFileExists = existsSync(previewFile);
+    if (isPreviewFileExists) {
+        mkdirSync(dirname(file), { recursive: true });
+        copyFileSync(previewFile, file);
+        return;
+    }
+    rmSync(file, { force: true });
+};
+export const executeMigrations = async (options) => {
+    const { executionPlan, isDryRun, onCommitChange, projectDir, } = options;
+    const { migrationPlans, targetProjectConfig, updatedProjectConfig, } = executionPlan;
+    const cleanUpTempDirs = [];
+    const previewProjectDir = createProjectModifiedPreview(projectDir, targetProjectConfig.managedFiles);
+    const generatedProjectDirs = new Map();
+    cleanUpTempDirs.push(previewProjectDir);
+    try {
+        const migrationDiffs = [];
+        for (const migrationPlan of migrationPlans) {
+            if (!generatedProjectDirs.has(migrationPlan.templateVersion)) {
+                const generatedProjectDir = generateProject(updatedProjectConfig, migrationPlan.templateVersion);
+                generatedProjectDirs.set(migrationPlan.templateVersion, generatedProjectDir);
+                cleanUpTempDirs.push(generatedProjectDir);
+            }
+            const generatedProjectDir = generatedProjectDirs.get(migrationPlan.templateVersion);
+            if (!generatedProjectDir) {
+                throw new Error(`Failed to generate project for template version ${migrationPlan.templateVersion}`);
+            }
+            const ctx = {
+                projectDir: previewProjectDir,
+                generatedProjectDir,
+                targetProjectConfig,
+                updatedProjectConfig,
+                templateVersion: migrationPlan.templateVersion,
+            };
+            const changes = await executeMigration(ctx, migrationPlan);
+            changes.forEach(({ filePath, relFilePath }) => {
+                const originFilePath = join(projectDir, relFilePath);
+                const diff = getChangeDiff(projectDir, originFilePath, filePath);
+                if (diff) {
+                    migrationDiffs.push({
+                        filePath: originFilePath,
+                        diff,
+                    });
+                    if (!isDryRun) {
+                        commitChange(originFilePath, filePath);
+                        onCommitChange?.(originFilePath, filePath);
+                    }
+                }
+            });
+        }
+        return migrationDiffs;
+    }
+    finally {
+        for (const tempDir of cleanUpTempDirs) {
+            rmSync(tempDir, { recursive: true, force: true });
+        }
+    }
+};

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

@@ -0,0 +1,3 @@
+import type { TMigrationChange, TMigrationContext, TMigrationPlan } from './types';
+export declare const getTemplateMigrationsDir: (type: "migrations" | "updates", version: number, managedFileRelPath: string) => string;
+export declare const executeMigration: (ctx: TMigrationContext, { scriptPath }: TMigrationPlan) => Promise<TMigrationChange[]>;

package/dist/src/migrator/migration.js

@@ -0,0 +1,18 @@
+import { basename, dirname, join } from 'node:path';
+import { AppError } from '../helpers/error.js';
+import { getIsValidMigration } from './validators/getIsValidMigration.js';
+const __dirname = import.meta.dirname;
+export const getTemplateMigrationsDir = (type, version, managedFileRelPath) => {
+    const base = basename(managedFileRelPath);
+    const dir = dirname(managedFileRelPath);
+    const migrationBase = base.replaceAll('.', '_');
+    return join(__dirname, type, `v${version}`, dir, migrationBase);
+};
+export const executeMigration = async (ctx, { scriptPath }) => {
+    const jsPath = scriptPath.replace(/\.(d\.ts|ts)$/, '.js');
+    const migration = await import(jsPath);
+    if (!getIsValidMigration(migration)) {
+        throw new AppError(`Invalid migration script contract: ${jsPath}. Expected named export "up".`);
+    }
+    return migration.up(ctx);
+};

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

@@ -0,0 +1,74 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } 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 { buildProjectConfig } from '../projectConfig/buildProjectConfig.js';
+import { MANAGED_TEMPLATES } from '../templates/constants.js';
+import { LAST_TEMPLATE_VERSION, TEMPLATES_DIR } from '../templates/templates.js';
+import { executeMigration, getTemplateMigrationsDir } from './migration.js';
+const testProjectConfig = buildProjectConfig({
+    category: 'games-and-fun',
+    framework: 'preact',
+    lastTemplateVersion: LAST_TEMPLATE_VERSION,
+    cliCommands: CLI_COMMANDS_MAP,
+    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',
+});
+describe('executeMigration', () => {
+    it('exec migration and return expected changes', async () => {
+        const testDir = mkdtempSync(join(tmpdir(), 'sce-exec-migration-and-return-changes-'));
+        try {
+            const projectDir = join(testDir, 'project-dir');
+            const generatedProjectDir = join(testDir, 'generated-project-dir');
+            mkdirSync(projectDir, { recursive: true });
+            mkdirSync(generatedProjectDir, { recursive: true });
+            const relFilePath = 'AGENTS.md';
+            writeFileSync(join(projectDir, relFilePath), 'project agents md', 'utf-8');
+            writeFileSync(join(generatedProjectDir, relFilePath), 'generated fresh agents md', 'utf-8');
+            const ctx = {
+                projectDir,
+                generatedProjectDir,
+                templateVersion: 2,
+                targetProjectConfig: testProjectConfig,
+                updatedProjectConfig: testProjectConfig,
+            };
+            const result = await executeMigration(ctx, {
+                scriptPath: join(getTemplateMigrationsDir('migrations', 2, relFilePath), '001_recreate-with-generated-part.ts'),
+                templateRelPath: `${relFilePath}.ejs`,
+                templateVersion: 2,
+            });
+            const expectedChanges = [
+                {
+                    filePath: join(projectDir, relFilePath),
+                    relFilePath,
+                },
+            ];
+            expect(result).toEqual(expectedChanges);
+        }
+        finally {
+            rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+    it('return throw error if migration is not valid', async () => {
+        const migrationPlan = {
+            scriptPath: '/invalid-path',
+            templateVersion: 2,
+            templateRelPath: 'AGENTS.md.ejs',
+        };
+        const ctx = {
+            projectDir: '/project-dir',
+            targetProjectConfig: testProjectConfig,
+            updatedProjectConfig: testProjectConfig,
+            templateVersion: migrationPlan.templateVersion,
+            generatedProjectDir: '/generated-project-dir',
+        };
+        const promise = executeMigration(ctx, migrationPlan);
+        await expect(promise).rejects.toThrow();
+    });
+});

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

@@ -0,0 +1,97 @@
+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 { 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_COMMANDS_MAP,
+    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) => {
+    const managedFiles = collectManagedFiles(TEMPLATES_DIR, MANAGED_TEMPLATES, templateVersion);
+    const diffFileRelPaths = [];
+    for (const managedFile of managedFiles) {
+        const targetFileContent = readFileSync(join(targetProjectDir, managedFile.relPath), {
+            encoding: 'utf-8',
+        });
+        const referenceFileContent = readFileSync(join(referenceProjectDir, managedFile.relPath), {
+            encoding: 'utf-8',
+        });
+        console.log('===>');
+        console.log('targetFileContent', targetFileContent);
+        console.log('referenceFileContent', referenceFileContent);
+        if (targetFileContent !== referenceFileContent) {
+            diffFileRelPaths.push(managedFile.relPath);
+        }
+    }
+    return diffFileRelPaths;
+};
+describe('migrations', () => {
+    const versionDirs = discoverVersionDirs(TEMPLATES_DIR, LAST_TEMPLATE_VERSION, 'asc');
+    for (const versionDir of versionDirs) {
+        if (versionDir.version === LAST_TEMPLATE_VERSION) {
+            break;
+        }
+        const fromVersion = versionDir.version;
+        const toVersion = versionDir.version + 1;
+        it(`runs migrations from v${fromVersion} to v${toVersion}`, 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: fromVersion,
+                });
+                const targetTemplateData = mapProjectConfigToTemplateData(targetProjectConfig);
+                const targetCommands = planProject(targetProjectDir, fromVersion, targetTemplateData);
+                executeCommands(targetCommands);
+                const referenceProjectConfig = buildProjectConfig({
+                    ...testBuildProjectConfigOptions,
+                    lastTemplateVersion: toVersion,
+                });
+                const referenceTemplateData = mapProjectConfigToTemplateData({
+                    ...referenceProjectConfig,
+                    lastTemplateVersion: toVersion,
+                });
+                const referenceCommands = planProject(referenceProjectDir, toVersion, referenceTemplateData);
+                executeCommands(referenceCommands);
+                const executionPlan = planMigrationExecution(targetProjectConfig, toVersion);
+                await executeMigrations({
+                    projectDir: targetProjectDir,
+                    executionPlan,
+                    isDryRun: false,
+                });
+                const result = compareManagedFiles(targetProjectDir, referenceProjectDir, toVersion);
+                expect(result).toEqual([]);
+                const idempotentExecutionPlan = planMigrationExecution(targetProjectConfig, toVersion);
+                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/migrations/v2/AGENTS_md/001_recreate-with-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/migrations/v2/AGENTS_md/001_recreate-with-generated-part.js

@@ -0,0 +1,14 @@
+import { copyFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { AGENTS_MD_REL_PATH, } from '../../../../constants.js';
+export const up = (ctx) => {
+    const targetAgentsMdFile = join(ctx.projectDir, AGENTS_MD_REL_PATH);
+    const generatedAgentsMdFile = join(ctx.generatedProjectDir, AGENTS_MD_REL_PATH);
+    copyFileSync(generatedAgentsMdFile, targetAgentsMdFile);
+    return [
+        {
+            filePath: targetAgentsMdFile,
+            relFilePath: AGENTS_MD_REL_PATH,
+        },
+    ];
+};

package/dist/src/migrator/migrations/v2/_project-config_json/001_create.d.ts

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

package/dist/src/migrator/migrations/v2/_project-config_json/001_create.js

@@ -0,0 +1,14 @@
+import { copyFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { PROJECT_CONFIG_REL_PATH } from '../../../../constants.js';
+export const up = (ctx) => {
+    const targetProjectConfigPath = join(ctx.projectDir, PROJECT_CONFIG_REL_PATH);
+    const generatedProjectConfigPath = join(ctx.generatedProjectDir, PROJECT_CONFIG_REL_PATH);
+    copyFileSync(generatedProjectConfigPath, targetProjectConfigPath);
+    return [
+        {
+            filePath: targetProjectConfigPath,
+            relFilePath: PROJECT_CONFIG_REL_PATH,
+        },
+    ];
+};

package/dist/src/migrator/migrations/v2/vite_config_ts/001_turn_off_minify_and_assets_inline.d.ts

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

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,
+        },
+    ];
+};