@astral/pack 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Astral.Soft
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,111 @@
+# @astral/pack
+
+Инструмент для сборки и релиза npm пакетов:
+- Собирает пакеты в esm и cjs
+  - Копирует статичные файлы
+  - Генерирует package.json
+- Semantic-release
+  - Проверяет актуальную версию пакета
+  - Создает релиз в gitlab и тэг в git
+
+## Installation
+
+```shell
+npm i --save @astral/utils
+```
+
+```shell
+yarn add @astral/utils
+```
+
+---
+
+## Build
+
+`pack.config.js`
+```js
+const { defineConfig } = require('@astral/pack');
+
+module.exports = defineConfig({
+  // Сборка в esm и cjs
+  format: ['esm', 'cjs'],
+  tsConfigName: 'tsconfig.build.json',
+  // Скопирует файлы в lib директорию
+  copyStaticFiles: {
+    filter: ['src/**/*.d.ts'],
+    ignoreSrc: true,
+  },
+  // Добавит к root exports дополнительный
+  packageExports: {
+    './server': {
+      module: './server/index.js',
+      require: './node/server/index.js',
+      types: './server/index.d.ts',
+    },
+  },
+});
+```
+
+```shell
+pack build --package-version=1.0.0
+```
+
+### Build в связке с sematic-release
+
+Запишет в `.pack/versions.json` новую версию пакета на основе анализа коммитов:
+```shell
+pack check-package-version
+```
+
+Заберет новую версию пакета из `.pack/versions.json`
+```shell
+pack build
+```
+
+## Создание релиза в git и gitlab
+
+```shell
+pack create-release
+```
+
+Создаст git тэг и релиз в gitlab.
+
+## Exports
+
+По-дефолту добавляет exports вида:
+```js
+{
+  '.': {
+    module: './index.js',
+    require: './node/index.js',
+    types: './index.d.ts'
+  },
+}
+```
+
+Для добавления доп. exports необходимо использовать `packageExports` в `pack.config.js`:
+```js
+module.exports = {
+  packageExports: {
+    './server': {
+      module: './server/index.js',
+      require: './node/server/index.js',
+      types: './server/index.d.ts',
+    },
+  },
+};
+```
+
+## Синхронный релиз пакетов
+
+Для того чтобы deps пакета были синхронизированы с основным пакетом необходимо использовать `semanticRelease.releaseGroup`:
+```js
+module.exports = {
+  semanticRelease: {
+    repositoryUrl: 'https://git.astralnalog.ru/frontend.shared/pack',
+    releaseGroup: ['@astral/validations'],
+  },
+};
+```
+
+`@astral/validations` будет иметь после сборки ту же версию, что и основной пакет.

package/bin.d.ts

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

package/bin.js

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import { build, checkPackageVersion, createRelease } from './commands';
+import { ConfigService } from './config';
+import { CLICommand, parseArgs } from './cli';
+console.log('process', process.env.CUSTOM);
+const start = async () => {
+    const { command, packageVersion } = parseArgs();
+    let configService;
+    try {
+        configService = new ConfigService();
+    }
+    catch (err) {
+        console.error(err);
+        process.exit(1);
+    }
+    switch (command) {
+        case CLICommand.CheckPackageVersion:
+            await checkPackageVersion(configService);
+            break;
+        case CLICommand.Build:
+            await build({ packageVersion }, configService);
+            break;
+        case CLICommand.CreateRelease:
+            await createRelease(configService);
+            break;
+    }
+};
+start();

package/cli/enums.d.ts

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

package/cli/enums.js

@@ -0,0 +1,6 @@
+export var CLICommand;
+(function (CLICommand) {
+    CLICommand["Build"] = "build";
+    CLICommand["CheckPackageVersion"] = "check-package-version";
+    CLICommand["CreateRelease"] = "create-release";
+})(CLICommand || (CLICommand = {}));

package/cli/index.d.ts

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

package/cli/index.js

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

package/cli/parseArgs/index.d.ts

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

package/cli/parseArgs/index.js

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

package/cli/parseArgs/parseArgs.d.ts

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

package/cli/parseArgs/parseArgs.js

@@ -0,0 +1,10 @@
+import { CLICommand } from '../enums';
+export const parseArgs = () => process.argv.reduce((result, arg) => {
+    if (Object.values(CLICommand).includes(arg)) {
+        result.command = arg;
+    }
+    if (arg.includes('--packageVersion')) {
+        result.packageVersion = arg.split('=')[1];
+    }
+    return result;
+}, { command: CLICommand.Build });

package/cli/types.d.ts

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

package/cli/types.js

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

package/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/commands/build/build.js

@@ -0,0 +1,48 @@
+import fs from 'fs';
+import path from 'path';
+import { compileJs } from '../compileJs';
+import { generatePackageJson } from '../generatePackageJson';
+import { compileTs } from '../compileTs';
+import { logger } from '../../services';
+import { rmDist } from '../rmDist';
+import { copyStatic } from '../copyStatic';
+import { copyDoc } from '../copyDoc';
+export const build = async (params, config) => {
+    const { packPrivateDirPath, semanticRelease, projectPath } = config;
+    let newPackageVersion = '';
+    const versionsFilePath = path.join(packPrivateDirPath, semanticRelease.versionsFileName);
+    if (params.packageVersion) {
+        newPackageVersion = params.packageVersion;
+    }
+    else {
+        if (fs.existsSync(versionsFilePath)) {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const { currentVersion, nextVersion } = require(`${packPrivateDirPath}/${semanticRelease.versionsFileName}`);
+            newPackageVersion = nextVersion;
+            logger.info('Версия пакета взята из файла', versionsFilePath, {
+                currentVersion,
+                nextVersion,
+            });
+        }
+    }
+    if (!newPackageVersion) {
+        const errorMessage = 'Не указана версия пакета для сборки';
+        logger.error(errorMessage);
+        throw new Error(errorMessage);
+    }
+    logger.info('Версия пакета', newPackageVersion);
+    rmDist(config);
+    if (config.copyStaticFiles) {
+        await copyStatic(config.copyStaticFiles, config);
+    }
+    const originPackageJson = JSON.parse(fs.readFileSync(path.join(projectPath, 'package.json'), 'utf8'));
+    const { lang } = config;
+    if (lang === 'js') {
+        await compileJs({ originPackageJson }, config);
+    }
+    else {
+        await compileTs(config);
+    }
+    await generatePackageJson({ packageVersion: newPackageVersion, originPackageJson }, config);
+    await copyDoc(config);
+};

package/commands/build/index.d.ts

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

package/commands/build/index.js

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

package/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/commands/compileJs/compileJs.js

@@ -0,0 +1,19 @@
+import path from 'path';
+import { copyStatic } from '../copyStatic';
+import { logger } from '../../services';
+export const compileJs = async ({ originPackageJson }, config) => {
+    const { main } = originPackageJson;
+    if (!main) {
+        throw Error('В package.json отсутствует main поле');
+    }
+    const srcDir = path.dirname(main).replace('./', '').replace('.', '') || 'src';
+    logger.progress('Копирование js файлов');
+    return copyStatic({ filter: [`${srcDir}/**/*.js`], ignoreSrc: true }, config)
+        .then(() => {
+        logger.success('js файлы успешно скопированы');
+    })
+        .catch((err) => {
+        logger.error('Ошибка копирования js файлов', err);
+        throw err;
+    });
+};

package/commands/compileJs/index.d.ts

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

package/commands/compileJs/index.js

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

package/commands/compileTs/compileTs.d.ts

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

package/commands/compileTs/compileTs.js

@@ -0,0 +1,45 @@
+import path from 'path';
+import { spawn } from 'node:child_process';
+import { logger } from '../../services';
+export const compileTs = (config) => {
+    const { tsConfigName, format, projectPath, distPath } = config;
+    const promises = [];
+    const execTs = (childProcess) => {
+        const { promise, resolve, reject } = Promise.withResolvers();
+        promises.push(promise);
+        childProcess.on('error', (err) => {
+            reject(err);
+        });
+        childProcess.on('exit', () => {
+            resolve();
+        });
+    };
+    logger.progress('Build ts файлов');
+    if (format?.includes('cjs')) {
+        execTs(spawn('tsc', [
+            '-p',
+            path.join(projectPath, tsConfigName),
+            '--module',
+            'commonjs',
+            '--outDir',
+            path.join(distPath, 'node'),
+        ], 
+        // Вывод логов в консоль
+        { stdio: 'inherit' }));
+    }
+    if (format?.includes('esm')) {
+        execTs(spawn('tsc', [
+            '-p',
+            path.join(projectPath, tsConfigName),
+            '--module',
+            'es2022',
+            '--outDir',
+            distPath,
+        ], 
+        // Вывод логов в консоль
+        { stdio: 'inherit' }));
+    }
+    return Promise.all(promises).then(() => {
+        logger.success('Сборка прошла успешно');
+    });
+};

package/commands/compileTs/index.d.ts

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

package/commands/compileTs/index.js

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

package/commands/copyDoc/copyDoc.d.ts

@@ -0,0 +1,5 @@
+import { ConfigService } from '../../config';
+/**
+ * Копирует README и license
+ */
+export declare const copyDoc: (config: ConfigService) => Promise<void>;

package/commands/copyDoc/copyDoc.js

@@ -0,0 +1,9 @@
+import { copyStatic } from '../copyStatic';
+import { logger } from '../../services';
+/**
+ * Копирует README и license
+ */
+export const copyDoc = async (config) => {
+    logger.progress('Копирование README.md и LICENSE');
+    return copyStatic({ filter: ['README.md', 'LICENSE'] }, config);
+};

package/commands/copyDoc/index.d.ts

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

package/commands/copyDoc/index.js

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

package/commands/copyStatic/copyStatic.d.ts

@@ -0,0 +1,7 @@
+import { ConfigService } from '../../config';
+type Params = {
+    filter: string[];
+    ignoreSrc?: boolean;
+};
+export declare const copyStatic: ({ filter, ignoreSrc }: Params, configService: ConfigService) => Promise<void>;
+export {};

package/commands/copyStatic/copyStatic.js

@@ -0,0 +1,17 @@
+import recursiveCopy from 'recursive-copy';
+import { logger } from '../../services';
+export const copyStatic = ({ filter, ignoreSrc }, configService) => {
+    const { projectPath, distPath } = configService;
+    logger.progress('Копирование статических файлов');
+    return recursiveCopy(projectPath, distPath, {
+        filter,
+        rename: (filePath) => (ignoreSrc ? filePath.replace('src/', '') : filePath),
+    })
+        .then((results) => {
+        logger.success('Статичные файлы скопированы:', results.map(({ src, dest }) => `${src} -> ${dest}`));
+    })
+        .catch((err) => {
+        logger.error('Ошибка копирования статических файлов');
+        throw err;
+    });
+};

package/commands/copyStatic/index.d.ts

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

package/commands/copyStatic/index.js

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

package/commands/generatePackageJson/generatePackageJson.d.ts

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

package/commands/generatePackageJson/generatePackageJson.js

@@ -0,0 +1,70 @@
+import path from 'path';
+import fs from 'fs';
+import { logger } from '../../services';
+const omitDevProps = (originPackageJson) => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { scripts, devDependencies, typesVersions, ...packageJson } = originPackageJson;
+    return packageJson;
+};
+/**
+ * Устанавливает пакетам из releaseGroup одну версию в зависимостях
+ */
+const initUpdatingReleaseGroup = (config, packageVersion) => (originPackageJson) => {
+    const { semanticRelease } = config;
+    const { releaseGroup } = semanticRelease;
+    if (!releaseGroup) {
+        return originPackageJson;
+    }
+    const { dependencies } = originPackageJson;
+    return {
+        ...originPackageJson,
+        dependencies: releaseGroup.reduce((deps, packageName) => {
+            deps[packageName] = packageVersion;
+            return deps;
+        }, dependencies),
+    };
+};
+const initExportsGenerator = ({ packageExports, format, lang }) => (originPackageJson) => {
+    const rootExports = {};
+    if (format.includes('esm')) {
+        rootExports.module = './index.js';
+    }
+    if (format.includes('cjs')) {
+        rootExports.require = './node/index.js';
+    }
+    if (lang === 'ts') {
+        rootExports.types = './index.d.ts';
+    }
+    return {
+        ...originPackageJson,
+        exports: {
+            '.': rootExports,
+            ...packageExports,
+        },
+    };
+};
+const initAdditionalCommonProps = (packageVersion, config) => (originPackageJson) => ({
+    ...originPackageJson,
+    version: packageVersion,
+    sideEffects: false,
+    types: './index.d.ts',
+    main: './node/index.js',
+    module: './index.js',
+    browser: './index.js',
+    author: 'Astral.Soft',
+    license: 'MIT',
+    repository: {
+        type: 'git',
+        url: config.semanticRelease.repositoryUrl,
+    },
+});
+export const generatePackageJson = async ({ packageVersion, originPackageJson }, config) => {
+    logger.progress('Генерация package.json');
+    const updateReleaseGroup = initUpdatingReleaseGroup(config, packageVersion);
+    const updateAdditionalCommonProps = initAdditionalCommonProps(packageVersion, config);
+    const generateExports = initExportsGenerator(config);
+    const packageJson = generateExports(omitDevProps(updateAdditionalCommonProps(updateReleaseGroup(originPackageJson))));
+    const { distPath } = config;
+    fs.writeFileSync(path.join(distPath, 'package.json'), JSON.stringify(packageJson, null, 2));
+    logger.success('package.json успешно сформирован в ', distPath);
+};

package/commands/generatePackageJson/index.d.ts

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

package/commands/generatePackageJson/index.js

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

package/commands/index.d.ts

@@ -0,0 +1,7 @@
+export * from './rmDist';
+export * from './copyStatic';
+export * from './compileTs';
+export * from './compileJs';
+export * from './build';
+export * from './semanticRelease';
+export * from './copyDoc';

package/commands/index.js

@@ -0,0 +1,7 @@
+export * from './rmDist';
+export * from './copyStatic';
+export * from './compileTs';
+export * from './compileJs';
+export * from './build';
+export * from './semanticRelease';
+export * from './copyDoc';

package/commands/rmDist/index.d.ts

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

package/commands/rmDist/index.js

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

package/commands/rmDist/rmDist.d.ts

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

package/commands/rmDist/rmDist.js

@@ -0,0 +1,17 @@
+import fs from 'fs';
+import { logger } from '../../services';
+export const rmDist = (configService) => {
+    const { distPath, distDirName } = configService;
+    if (!fs.existsSync(distPath)) {
+        return;
+    }
+    logger.progress(`Удаление ${distDirName} директории`);
+    try {
+        fs.rmSync(distPath, { recursive: true, force: true });
+        logger.success(`${distDirName} директория удалена`);
+    }
+    catch (err) {
+        logger.error(`Ошибка удаления ${distDirName} директории`, err);
+        throw err;
+    }
+};

package/commands/semanticRelease/checkPackageVersion/checkPackageVersion.d.ts

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

package/commands/semanticRelease/checkPackageVersion/checkPackageVersion.js

@@ -0,0 +1,50 @@
+import fs from 'fs';
+import path from 'path';
+import semanticRelease from 'semantic-release';
+import { logger } from '../../../services';
+import { commitAnalyzerPlugin, defaultBranches } from '../defaultConfig';
+export const checkPackageVersion = async (config) => {
+    logger.progress('Анализ коммитов');
+    let versions;
+    try {
+        const result = await semanticRelease({
+            branches: defaultBranches,
+            plugins: [commitAnalyzerPlugin],
+            dryRun: true,
+            ci: true,
+        });
+        if (result) {
+            logger.success('Коммиты успешно проанализированы');
+            const { lastRelease, nextRelease } = result;
+            versions = {
+                currentVersion: lastRelease.version ?? null,
+                nextVersion: nextRelease.version ?? null,
+            };
+            logger.info('Версии пакета:', versions);
+        }
+        else {
+            throw new Error('Не удалось провести анализ коммитов');
+        }
+    }
+    catch (err) {
+        logger.error('Ошибка анализа коммитов', err);
+        throw err;
+    }
+    if (versions.currentVersion === versions.nextVersion) {
+        throw Error('Версии пакетов совпадают');
+    }
+    const { packPrivateDirPath, semanticRelease: semanticReleaseConfig } = config;
+    const versionFilePath = path.join(packPrivateDirPath, semanticReleaseConfig.versionsFileName);
+    logger.progress('Запись данных о версиях в файл', versionFilePath);
+    try {
+        if (!fs.existsSync(packPrivateDirPath)) {
+            fs.mkdirSync('.pack');
+        }
+        fs.writeFileSync(versionFilePath, JSON.stringify(versions));
+        logger.success('Данные о версиях в файл успешно записаны');
+    }
+    catch (err) {
+        logger.error('Ошибка записи данных о версиях в файл', err);
+        throw err;
+    }
+};

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

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

package/commands/semanticRelease/checkPackageVersion/index.js

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

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

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