@astral/pack 0.1.0

package/commands/semanticRelease/createRelease/createRelease.js

@@ -0,0 +1,25 @@
+import semanticRelease from 'semantic-release';
+import { logger } from '../../../services';
+import { getDefaultConfig } from '../defaultConfig';
+export const createRelease = async (config) => {
+    logger.progress('Добавление git тэгов и создание релиза в gitlab');
+    try {
+        const semanticReleaseConfig = getDefaultConfig(config.semanticRelease);
+        const result = await semanticRelease({
+            ...semanticReleaseConfig,
+            plugins: semanticReleaseConfig.plugins,
+            ci: true,
+        });
+        if (result) {
+            const { nextRelease } = result;
+            logger.success(`Релиз ${nextRelease.version} успешно создан`);
+        }
+        else {
+            throw new Error('Не удалось провести анализ коммитов');
+        }
+    }
+    catch (err) {
+        logger.error('Ошибка создания релиза', err);
+        throw err;
+    }
+};

package/commands/semanticRelease/createRelease/index.d.ts

@@ -0,0 +1 @@
+export * from './createRelease';

package/commands/semanticRelease/createRelease/index.js

@@ -0,0 +1 @@
+export * from './createRelease';

package/commands/semanticRelease/defaultConfig.d.ts

@@ -0,0 +1,39 @@
+type Params = {
+    repositoryUrl: string;
+};
+export declare const defaultBranches: (string | {
+    name: string;
+    prerelease: boolean;
+})[];
+export declare const commitAnalyzerPlugin: (string | {
+    releaseRules: {
+        type: string;
+        release: string;
+    }[];
+})[];
+export declare const getDefaultConfig: ({ repositoryUrl }: Params) => {
+    branches: (string | {
+        name: string;
+        prerelease: boolean;
+    })[];
+    repositoryUrl: string;
+    plugins: ((string | {
+        releaseRules: {
+            type: string;
+            release: string;
+        }[];
+    })[] | (string | {
+        preset: string;
+        linkReferences: boolean;
+        presetConfig: {
+            types: {
+                type: string;
+                section: string;
+                hidden: boolean;
+            }[];
+        };
+    })[] | (string | {
+        gitlabUrl: string;
+    })[])[];
+};
+export {};

package/commands/semanticRelease/defaultConfig.js

@@ -0,0 +1,63 @@
+export const defaultBranches = [
+    'main',
+    'feat/build',
+    { name: 'rc', prerelease: true },
+];
+export const commitAnalyzerPlugin = [
+    '@semantic-release/commit-analyzer',
+    {
+        releaseRules: [
+            { type: 'bug', release: 'patch' },
+            { type: 'build', release: 'patch' },
+            { type: 'feat', release: 'minor' },
+            { type: 'refactor', release: 'patch' },
+            { type: 'major', release: 'major' },
+            { type: 'doc', release: 'patch' },
+        ],
+    },
+];
+export const getDefaultConfig = ({ repositoryUrl }) => ({
+    branches: defaultBranches,
+    repositoryUrl,
+    plugins: [
+        commitAnalyzerPlugin,
+        [
+            '@semantic-release/release-notes-generator',
+            {
+                // cspell:ignore conventionalcommits
+                preset: 'conventionalcommits',
+                linkReferences: true,
+                presetConfig: {
+                    types: [
+                        {
+                            type: 'bug',
+                            section: '🐞 Bugs',
+                            hidden: false,
+                        },
+                        {
+                            type: 'feat',
+                            section: '✨ Features',
+                            hidden: false,
+                        },
+                        {
+                            type: 'build',
+                            section: '📦 Build',
+                            hidden: false,
+                        },
+                        {
+                            type: 'doc',
+                            section: '📄 Docs',
+                            hidden: false,
+                        },
+                    ],
+                },
+            },
+        ],
+        [
+            '@semantic-release/gitlab',
+            {
+                gitlabUrl: 'https://git.astralnalog.ru',
+            },
+        ],
+    ],
+});

package/commands/semanticRelease/index.d.ts

@@ -0,0 +1,2 @@
+export * from './checkPackageVersion';
+export * from './createRelease';

package/commands/semanticRelease/index.js

@@ -0,0 +1,2 @@
+export * from './checkPackageVersion';
+export * from './createRelease';

package/config/ConfigService/ConfigService.d.ts

@@ -0,0 +1,27 @@
+import { CopyStaticFilesConfig, Lang, PackConfig } from '../types';
+export declare class ConfigService {
+    readonly projectPath: string;
+    /**
+     * Директория, где хранятся приватные файлы для @astral/pack
+     */
+    readonly packPrivateDirPath: string;
+    readonly lang: Lang;
+    private readonly configName;
+    private readonly logger;
+    private readonly config;
+    constructor();
+    get sourcePath(): string;
+    get distDirName(): string;
+    get distPath(): string;
+    get copyStaticFiles(): CopyStaticFilesConfig | undefined;
+    get format(): PackConfig['format'];
+    get tsConfigName(): string;
+    get semanticRelease(): {
+        versionsFileName: string;
+        repositoryUrl: string;
+        releaseGroup?: string[];
+    };
+    get packageExports(): import("../types").PackageExports | undefined;
+    private parseConfig;
+    private checkLanguage;
+}

package/config/ConfigService/ConfigService.js

@@ -0,0 +1,76 @@
+import path from 'path';
+import fs from 'fs';
+import * as v from '@astral/validations';
+import { Logger } from '../../services';
+import { validateConfig } from './validation';
+export class ConfigService {
+    projectPath = process.cwd();
+    /**
+     * Директория, где хранятся приватные файлы для @astral/pack
+     */
+    packPrivateDirPath;
+    lang;
+    configName = 'pack.config.js';
+    logger = new Logger();
+    config;
+    constructor() {
+        this.config = this.parseConfig();
+        this.lang = this.checkLanguage();
+        this.packPrivateDirPath = path.join(this.projectPath, '.pack');
+    }
+    get sourcePath() {
+        if (fs.existsSync(path.join(this.projectPath, 'src'))) {
+            return path.join(this.projectPath, 'src');
+        }
+        return this.projectPath;
+    }
+    get distDirName() {
+        return this.config.distDirName || 'lib';
+    }
+    get distPath() {
+        return path.join(this.projectPath, this.distDirName);
+    }
+    get copyStaticFiles() {
+        if (!this.config.copyStaticFiles) {
+            return undefined;
+        }
+        return { ignoreSrc: true, ...this.config.copyStaticFiles };
+    }
+    get format() {
+        return this.config.format;
+    }
+    get tsConfigName() {
+        return this.config.tsConfigName || 'tsconfig.json';
+    }
+    get semanticRelease() {
+        return {
+            ...this.config.semanticRelease,
+            versionsFileName: 'versions.json',
+        };
+    }
+    get packageExports() {
+        return this.config.packageExports;
+    }
+    parseConfig = () => {
+        const configPath = path.join(this.projectPath, this.configName);
+        if (!fs.existsSync(configPath)) {
+            this.logger.error('pack.config.js не найден');
+            throw Error('pack.config.js не найден');
+        }
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const config = require(configPath);
+        const validationError = validateConfig(config);
+        if (validationError) {
+            this.logger.error('Ошибка валидации config', v.toPrettyError(validationError));
+            throw new Error('Ошибка валидации config');
+        }
+        return config;
+    };
+    checkLanguage = () => {
+        const tsConfigPath = path.join(this.projectPath, this.tsConfigName);
+        if (fs.existsSync(tsConfigPath)) {
+            return 'ts';
+        }
+        return 'js';
+    };
+}

package/config/ConfigService/index.d.ts

@@ -0,0 +1 @@
+export * from './ConfigService';

package/config/ConfigService/index.js

@@ -0,0 +1 @@
+export * from './ConfigService';

package/config/ConfigService/validation.d.ts

@@ -0,0 +1,3 @@
+export declare const validateConfig: import("@astral/validations/core").Guard<{}, {
+    isPartial?: boolean;
+}>;

package/config/ConfigService/validation.js

@@ -0,0 +1,28 @@
+import * as v from '@astral/validations';
+export const validateConfig = v.object({
+    distDirName: v.optional(v.string()),
+    copyStaticFiles: v.optional(v.object({
+        filter: v.array(v.arrayItem(v.string())),
+        ignoreSrc: v.optional(v.boolean()),
+    })),
+    tsConfigName: v.optional(v.string()),
+    format: v.array(v.arrayItem(v.string())),
+    semanticRelease: v.object({
+        repositoryUrl: v.string(),
+        releaseGroup: v.optional(v.array(v.arrayItem(v.string()))),
+    }),
+    packageExports: (value) => {
+        const objectError = v.optional(v.object({}))(value);
+        if (objectError) {
+            return objectError;
+        }
+        const errors = Object.values(value)
+            .map((exportValue) => v.object({
+            require: v.string(),
+            module: v.string(),
+            types: v.string(),
+        })(exportValue))
+            .filter(Boolean);
+        return errors[0];
+    },
+});

package/config/defineConfig/defineConfig.d.ts

@@ -0,0 +1,2 @@
+import { PackConfig } from '../types';
+export declare const defineConfig: (config: PackConfig) => PackConfig;

package/config/defineConfig/defineConfig.js

@@ -0,0 +1 @@
+export const defineConfig = (config) => config;

package/config/defineConfig/index.d.ts

@@ -0,0 +1 @@
+export * from './defineConfig';

package/config/defineConfig/index.js

@@ -0,0 +1 @@
+export * from './defineConfig';

package/config/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './ConfigService';
+export * from './defineConfig';

package/config/index.js

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './ConfigService';
+export * from './defineConfig';

package/config/types.d.ts

@@ -0,0 +1,54 @@
+export type CopyStaticFilesConfig = {
+    /**
+     * Используется glob паттерн
+     * @example ['src/declarations/*d.ts']
+     */
+    filter: string[];
+    /**
+     * Если true, то при перемещении в пакет удалит src в пути
+     * @default true
+     */
+    ignoreSrc?: boolean;
+};
+export type SemanticReleaseConfig = {
+    /**
+     * @example https://git.astralnalog.ru/frontend.shared/pack
+     */
+    repositoryUrl: string;
+    /**
+     * Имена пакетов, которые должны релизиться синхронно одной версией.
+     * Подменить версии этих пакетов в deps на текущую версию пакета
+     */
+    releaseGroup?: string[];
+};
+export type PackageExportsItem = {
+    module: string;
+    require: string;
+    types: string;
+};
+export type PackageExports = Record<string, PackageExportsItem>;
+export type PackConfig = {
+    /**
+     * @default берет module из tsconfig.json
+     */
+    format: Array<'esm' | 'cjs'>;
+    /**
+     * @default lib
+     */
+    distDirName?: string;
+    /**
+     * Копирует статичные файлы в пакет. Используется glob паттерн
+     * @example src/declarations/*d.ts
+     */
+    copyStaticFiles?: CopyStaticFilesConfig;
+    /**
+     * @default tsconfig.json
+     */
+    tsConfigName?: string;
+    semanticRelease: SemanticReleaseConfig;
+    /**
+     * exports свойство package.json
+     */
+    packageExports?: PackageExports;
+};
+export type Lang = 'js' | 'ts';

package/config/types.js

@@ -0,0 +1 @@
+export {};

package/index.d.ts

@@ -0,0 +1 @@
+export { type PackConfig, defineConfig } from './config';

package/index.js

@@ -0,0 +1 @@
+export { defineConfig } from './config';

package/node/bin.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/node/bin.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commands_1 = require("./commands");
+const config_1 = require("./config");
+const cli_1 = require("./cli");
+console.log('process', process.env.CUSTOM);
+const start = async () => {
+    const { command, packageVersion } = (0, cli_1.parseArgs)();
+    let configService;
+    try {
+        configService = new config_1.ConfigService();
+    }
+    catch (err) {
+        console.error(err);
+        process.exit(1);
+    }
+    switch (command) {
+        case cli_1.CLICommand.CheckPackageVersion:
+            await (0, commands_1.checkPackageVersion)(configService);
+            break;
+        case cli_1.CLICommand.Build:
+            await (0, commands_1.build)({ packageVersion }, configService);
+            break;
+        case cli_1.CLICommand.CreateRelease:
+            await (0, commands_1.createRelease)(configService);
+            break;
+    }
+};
+start();

package/node/cli/enums.d.ts

@@ -0,0 +1,5 @@
+export declare enum CLICommand {
+    Build = "build",
+    CheckPackageVersion = "check-package-version",
+    CreateRelease = "create-release"
+}

package/node/cli/enums.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLICommand = void 0;
+var CLICommand;
+(function (CLICommand) {
+    CLICommand["Build"] = "build";
+    CLICommand["CheckPackageVersion"] = "check-package-version";
+    CLICommand["CreateRelease"] = "create-release";
+})(CLICommand || (exports.CLICommand = CLICommand = {}));

package/node/cli/index.d.ts

@@ -0,0 +1,2 @@
+export * from './enums';
+export * from './parseArgs';

package/node/cli/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./enums"), exports);
+__exportStar(require("./parseArgs"), exports);

package/node/cli/parseArgs/index.d.ts

@@ -0,0 +1 @@
+export * from './parseArgs';

package/node/cli/parseArgs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./parseArgs"), exports);

package/node/cli/parseArgs/parseArgs.d.ts

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

package/node/cli/parseArgs/parseArgs.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = void 0;
+const enums_1 = require("../enums");
+const parseArgs = () => process.argv.reduce((result, arg) => {
+    if (Object.values(enums_1.CLICommand).includes(arg)) {
+        result.command = arg;
+    }
+    if (arg.includes('--packageVersion')) {
+        result.packageVersion = arg.split('=')[1];
+    }
+    return result;
+}, { command: enums_1.CLICommand.Build });
+exports.parseArgs = parseArgs;

package/node/cli/types.d.ts

@@ -0,0 +1,5 @@
+import { CLICommand } from './enums';
+export type CLIArgs = {
+    command: CLICommand;
+    packageVersion?: string;
+};

package/node/cli/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/node/commands/build/build.d.ts

@@ -0,0 +1,6 @@
+import { ConfigService } from '../../config';
+type Params = {
+    packageVersion?: string;
+};
+export declare const build: (params: Params, config: ConfigService) => Promise<void>;
+export {};

package/node/commands/build/build.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.build = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const compileJs_1 = require("../compileJs");
+const generatePackageJson_1 = require("../generatePackageJson");
+const compileTs_1 = require("../compileTs");
+const services_1 = require("../../services");
+const rmDist_1 = require("../rmDist");
+const copyStatic_1 = require("../copyStatic");
+const copyDoc_1 = require("../copyDoc");
+const build = async (params, config) => {
+    const { packPrivateDirPath, semanticRelease, projectPath } = config;
+    let newPackageVersion = '';
+    const versionsFilePath = path_1.default.join(packPrivateDirPath, semanticRelease.versionsFileName);
+    if (params.packageVersion) {
+        newPackageVersion = params.packageVersion;
+    }
+    else {
+        if (fs_1.default.existsSync(versionsFilePath)) {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { currentVersion, nextVersion } = require(`${packPrivateDirPath}/${semanticRelease.versionsFileName}`);
+            newPackageVersion = nextVersion;
+            services_1.logger.info('Версия пакета взята из файла', versionsFilePath, {
+                currentVersion,
+                nextVersion,
+            });
+        }
+    }
+    if (!newPackageVersion) {
+        const errorMessage = 'Не указана версия пакета для сборки';
+        services_1.logger.error(errorMessage);
+        throw new Error(errorMessage);
+    }
+    services_1.logger.info('Версия пакета', newPackageVersion);
+    (0, rmDist_1.rmDist)(config);
+    if (config.copyStaticFiles) {
+        await (0, copyStatic_1.copyStatic)(config.copyStaticFiles, config);
+    }
+    const originPackageJson = JSON.parse(fs_1.default.readFileSync(path_1.default.join(projectPath, 'package.json'), 'utf8'));
+    const { lang } = config;
+    if (lang === 'js') {
+        await (0, compileJs_1.compileJs)({ originPackageJson }, config);
+    }
+    else {
+        await (0, compileTs_1.compileTs)(config);
+    }
+    await (0, generatePackageJson_1.generatePackageJson)({ packageVersion: newPackageVersion, originPackageJson }, config);
+    await (0, copyDoc_1.copyDoc)(config);
+};
+exports.build = build;

package/node/commands/build/index.d.ts

@@ -0,0 +1 @@
+export * from './build';

package/node/commands/build/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./build"), exports);

package/node/commands/compileJs/compileJs.d.ts

@@ -0,0 +1,6 @@
+import { ConfigService } from '../../config';
+type Params = {
+    originPackageJson: Record<string, unknown>;
+};
+export declare const compileJs: ({ originPackageJson }: Params, config: ConfigService) => Promise<void>;
+export {};

package/node/commands/compileJs/compileJs.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileJs = void 0;
+const path_1 = __importDefault(require("path"));
+const copyStatic_1 = require("../copyStatic");
+const services_1 = require("../../services");
+const compileJs = async ({ originPackageJson }, config) => {
+    const { main } = originPackageJson;
+    if (!main) {
+        throw Error('В package.json отсутствует main поле');
+    }
+    const srcDir = path_1.default.dirname(main).replace('./', '').replace('.', '') || 'src';
+    services_1.logger.progress('Копирование js файлов');
+    return (0, copyStatic_1.copyStatic)({ filter: [`${srcDir}/**/*.js`], ignoreSrc: true }, config)
+        .then(() => {
+        services_1.logger.success('js файлы успешно скопированы');
+    })
+        .catch((err) => {
+        services_1.logger.error('Ошибка копирования js файлов', err);
+        throw err;
+    });
+};
+exports.compileJs = compileJs;

package/node/commands/compileJs/index.d.ts

@@ -0,0 +1 @@
+export * from './compileJs';

package/node/commands/compileJs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./compileJs"), exports);

package/node/commands/compileTs/compileTs.d.ts

@@ -0,0 +1,2 @@
+import { ConfigService } from '../../config';
+export declare const compileTs: (config: ConfigService) => Promise<void>;