@infomaximum/package-cli 2.11.0 → 2.12.0-rc.1

package/README.md

@@ -6,6 +6,8 @@
     <img alt="npm" src="https://img.shields.io/npm/v/@infomaximum/package-cli?style=for-the-badge">
 </a>
 
+---
+
 ## Разработка виджета
 
 ### Инициализация проекта
@@ -97,7 +99,7 @@
 
 Эта конфигурация определяет, как будет собираться и запускаться ваш пакет с использованием `@infomaximum/package-cli`.
 
-## Версионирование пакета `(2.10.0)`
+### Версионирование `(2.10.0)`
 
 `@infomaximum/package-cli` реализует возможность автоматизированного [семантического версионирования](https://semver.org/lang/ru/) для управления версиями пакетов. Версия пакета автоматически вычисляется на основе сообщений коммитов в репозиторий:
 
@@ -110,6 +112,18 @@
 Создать релиз можно используя команду
 `yarn im-package-cli widget release`
 
+---
+
+## Разработка интеграции
+
+### Инициализация проекта
+
+Для создания нового пакета с интеграцией необходимо выполнить следующую команду:
+
+`npx @infomaximum/package-cli integration init my_integration`
+
+После выполнения данной команды будет создан шаблонный проект **my_integration** и инициализирован git репозиторий.
+
 ## Вывод всех доступных команд
 
 Вы можете использовать флаг `-h`, чтобы просмотреть список всех доступных команд и их описаний:

package/dist/arguments.js

@@ -1,9 +1,11 @@
 import { systemRequire } from "./utils.js";
 import { registerWidgetCommands } from "./widget/index.js";
+import { registerIntegrationCommands } from "./integration/index.js";
 const packageJson = systemRequire("../package.json");
 export const registerCommands = (cli) => {
     cli.helpOption("-h", "отображает помощь по командам");
     cli.name("im-package-cli");
     cli.version(packageJson.version, "-v, --version", "текущая версия библиотеки");
     registerWidgetCommands(cli);
+    registerIntegrationCommands(cli);
 };

package/dist/const.js

@@ -5,3 +5,4 @@ export const MANIFEST_REG_EXP = new RegExp(`${MANIFEST_JSON_FILE_NAME}$`, "i");
 export const DEV_POSTFIX = "__DEV";
 export const DEFAULT_BUILD_DIR_NAME = "build";
 export const MANIFEST_SERVICE_FIELDS_FOR_DEVELOPMENT = ["$schema"];
+export const AVAILABLE_LANGUAGES = ["ru", "en"];

package/dist/integration/commands/build.js

@@ -0,0 +1,13 @@
+import { runBuildIntegration } from "../scripts/build.js";
+import { registerPackageOptions, } from "../../package/commands.js";
+export const registerIntegrationBuildCommand = (integrationCommand) => {
+    const integrationBuildCommand = integrationCommand.command("build");
+    registerPackageOptions(integrationBuildCommand);
+    integrationBuildCommand
+        .description("Выполняет сборку пакета c интеграцией")
+        .option("--entry <path>", "путь до entrypoint", "src/index.ts")
+        .option("--build-dir <buildDirPath>", "путь до директории в которую будет собран пакет", "build")
+        .option("--type <buildType>", "тип сборки, <package> - сборка пакета (в архив), <script> - сборка в js файл", "package")
+        .option("--watch", "при изменении файлов скрипт будет пересобран", false)
+        .action((options) => runBuildIntegration(options));
+};

package/dist/integration/commands/init.js

@@ -0,0 +1,15 @@
+import { __awaiter } from "tslib";
+import { runInitEntityScript } from "../../plopHelpers.js";
+import { getInitIntegrationActions } from "../scripts/actions.js";
+export const registerIntegrationInitCommand = (integrationCommand) => {
+    const widgetInitCommand = integrationCommand.command("init <project-directory>");
+    widgetInitCommand
+        .description("Инициализация проекта интеграции")
+        .action((dirName) => __awaiter(void 0, void 0, void 0, function* () {
+        runInitEntityScript({
+            dirName,
+            entity: "integration",
+            actions: yield getInitIntegrationActions(),
+        });
+    }));
+};

package/dist/integration/commands.js

@@ -0,0 +1,7 @@
+import { registerIntegrationInitCommand } from "./commands/init.js";
+import { registerIntegrationBuildCommand } from "./commands/build.js";
+export const registerIntegrationCommands = (cli) => {
+    const integrationCommand = cli.command("integration");
+    registerIntegrationInitCommand(integrationCommand);
+    registerIntegrationBuildCommand(integrationCommand);
+};

package/dist/integration/configs/webpack/common.js

@@ -0,0 +1,50 @@
+import TerserPlugin from "terser-webpack-plugin";
+import { systemRequire } from "../../../utils.js";
+export const getCommonIntegrationConfig = (mode, PATHS) => {
+    return {
+        mode,
+        entry: PATHS.moduleIndex,
+        output: {
+            filename: PATHS.outputFile,
+            path: PATHS.appBuildPath,
+            clean: true,
+            libraryTarget: "module",
+        },
+        experiments: {
+            outputModule: true,
+        },
+        resolve: {
+            extensions: [".ts", ".js", ".json"],
+        },
+        module: {
+            rules: [
+                {
+                    test: /\.(js|ts|jsx|tsx)$/i,
+                    exclude: ["/node_modules/"],
+                    loader: systemRequire.resolve("babel-loader"),
+                    options: {
+                        plugins: [
+                            systemRequire.resolve("babel-plugin-inline-json-import"),
+                            systemRequire.resolve("@babel/plugin-transform-runtime"),
+                        ].filter(Boolean),
+                    },
+                },
+            ],
+        },
+        optimization: {
+            minimize: true,
+            concatenateModules: true,
+            splitChunks: false,
+            runtimeChunk: false,
+            minimizer: [
+                new TerserPlugin({
+                    terserOptions: {
+                        compress: {
+                            booleans: false,
+                        },
+                    },
+                }),
+            ],
+        },
+    };
+};

package/dist/integration/const.js

@@ -0,0 +1 @@
+export const INTEGRATION_SDK_LIB_NAME = "@infomaximum/integration-sdk";

package/dist/integration/index.js

@@ -0,0 +1 @@
+export { registerIntegrationCommands } from "./commands.js";

package/dist/integration/integrationPaths.js

@@ -0,0 +1,12 @@
+import { generatePackagePaths } from "../package/packagePaths.js";
+import { generateIndexPath } from "../paths.js";
+export function generateIntegrationPaths({ entry, buildDir, packageDir, packageManifest, }) {
+    const packagePaths = generatePackagePaths({
+        buildDir,
+        packageDir,
+        packageManifest,
+    });
+    return Object.assign(Object.assign({}, packagePaths), { outputFile: "integration.js", get moduleIndex() {
+            return generateIndexPath(entry);
+        } });
+}

package/dist/integration/scripts/actions.js

@@ -0,0 +1,53 @@
+import { __awaiter } from "tslib";
+import { CUSTOM_PACKAGE_CLI_LIB_NAME } from "../../const.js";
+import { INTEGRATION_BABEL_CONFIG, INTEGRATION_ESLINTRC, INTEGRATION_GITIGNORE, INTEGRATION_TSCONFIG_JSON, } from "../templates/integrationConfigs.js";
+import { getPackageActions } from "../../package/scripts/actions.js";
+import { INTEGRATION_INDEX_TEMPLATE } from "../templates/integrationIndex.js";
+import { INTEGRATION_PACKAGE_JSON_TEMPLATE } from "../templates/integrationPackageJson.js";
+import { getLatestVersionOfLibrary } from "../../utils.js";
+import { INTEGRATION_SDK_LIB_NAME } from "../const.js";
+const actions = ({ packageCliVersion, integrationSdkVersion }) => {
+    return [
+        ...getPackageActions({ packageType: "integration" }),
+        {
+            type: "add",
+            path: "src/index.ts",
+            template: INTEGRATION_INDEX_TEMPLATE,
+        },
+        {
+            type: "add",
+            path: "tsconfig.json",
+            template: INTEGRATION_TSCONFIG_JSON,
+        },
+        {
+            type: "add",
+            path: "babel.config.js",
+            template: INTEGRATION_BABEL_CONFIG,
+        },
+        {
+            type: "add",
+            path: ".gitignore",
+            template: INTEGRATION_GITIGNORE,
+        },
+        {
+            type: "add",
+            path: "eslint.config.js",
+            template: INTEGRATION_ESLINTRC,
+        },
+        {
+            type: "add",
+            path: "package.json",
+            template: INTEGRATION_PACKAGE_JSON_TEMPLATE,
+            data: { packageCliVersion, integrationSdkVersion },
+        },
+    ];
+};
+const getInitIntegrationActions = () => __awaiter(void 0, void 0, void 0, function* () {
+    const [packageCliVersion, integrationSdkVersion] = yield Promise.all([
+        getLatestVersionOfLibrary(CUSTOM_PACKAGE_CLI_LIB_NAME),
+        getLatestVersionOfLibrary(INTEGRATION_SDK_LIB_NAME),
+    ]);
+    return (data) => actions(Object.assign(Object.assign({}, data), { packageCliVersion,
+        integrationSdkVersion }));
+});
+export { getInitIntegrationActions };

package/dist/integration/scripts/build.js

@@ -0,0 +1,48 @@
+import { __awaiter } from "tslib";
+import webpack, {} from "webpack";
+import { handleWebpackCallback, runWebpackBuild } from "../../utils.js";
+import { getCommonIntegrationConfig } from "../configs/webpack/common.js";
+import { generateIntegrationPaths } from "../integrationPaths.js";
+import chalk from "chalk";
+import { getPackageBuildConfig } from "../../package/configs/webpack/buildPackage.js";
+import path from "path";
+import { merge } from "webpack-merge";
+export const runBuildIntegration = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const { entry, buildDir, packageDir, packageManifest, type, watch } = options;
+    const INTEGRATION_PATHS = generateIntegrationPaths({
+        entry,
+        buildDir,
+        packageDir,
+        packageManifest,
+    });
+    const mode = "production";
+    const commonConfig = getCommonIntegrationConfig(mode, INTEGRATION_PATHS);
+    const config = merge([
+        commonConfig,
+        watch && {
+            watch: true,
+        },
+    ]);
+    const integrationScriptPath = path.resolve(INTEGRATION_PATHS.appBuildPath, INTEGRATION_PATHS.outputFile);
+    if (watch) {
+        webpack(config, (err, stats) => handleWebpackCallback(err, stats));
+        return;
+    }
+    try {
+        yield runWebpackBuild(config);
+        if (type === "package" && !watch) {
+            yield runWebpackBuild(yield getPackageBuildConfig({
+                mode,
+                PATHS: INTEGRATION_PATHS,
+                isBuildDevMode: false,
+                entityArchivePath: integrationScriptPath,
+                copyFiles: [{ from: integrationScriptPath }],
+            }));
+        }
+    }
+    catch (error) {
+        console.error(chalk.red("\nFailed to compile.\n"));
+        console.error(chalk.red(error));
+        process.exit(1);
+    }
+});

package/dist/integration/templates/integrationConfigs.js

@@ -0,0 +1,68 @@
+export const INTEGRATION_TSCONFIG_JSON = `\
+{
+  "compilerOptions": {
+    "target": "ES5",
+    "module": "Preserve",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "isolatedModules": false
+  },
+  "include": ["src"]
+}
+`;
+export const INTEGRATION_BABEL_CONFIG = `\
+module.exports = {
+  presets: [
+    "@babel/preset-env",
+    "@babel/preset-typescript",
+  ],
+};
+`;
+export const INTEGRATION_GITIGNORE = `\
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+
+# testing
+/coverage
+
+# production
+/dist
+
+# misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+/build
+.ultra.cache.json
+*.tsbuildinfo
+`;
+export const INTEGRATION_ESLINTRC = `\
+import js from "@eslint/js";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+
+export default tseslint.config(
+  { ignores: ["dist", "build"] },
+  {
+    extends: [js.configs.recommended, ...tseslint.configs.recommended],
+    files: ["**/*.{ts,tsx}"],
+    languageOptions: {
+      ecmaVersion: 2020,
+      globals: globals.browser,
+    },
+    plugins: {},
+    rules: {},
+  }
+);
+`;

package/dist/integration/templates/integrationIndex.js

@@ -0,0 +1,15 @@
+import { INTEGRATION_SDK_LIB_NAME } from "../const.js";
+export const INTEGRATION_INDEX_TEMPLATE = `\
+/// <reference types="${INTEGRATION_SDK_LIB_NAME}" />
+
+integration = {
+  schema: 1,
+  meta: {
+    key: "integrationKey",
+    name: "",
+    description: "",
+  },
+  blocks: [],
+  connections: [],
+};
+`;

package/dist/integration/templates/integrationPackageJson.js

@@ -0,0 +1,28 @@
+import { CUSTOM_PACKAGE_CLI_LIB_NAME } from "../../const.js";
+import { INTEGRATION_SDK_LIB_NAME } from "../const.js";
+export const INTEGRATION_PACKAGE_JSON_TEMPLATE = `\
+{
+  "name": "template_integration",
+  "version": "1.0.0",
+  "main": "src/index.ts",
+  "scripts": {
+    "build": "im-package-cli integration build",
+    "dev": "im-package-cli integration build --watch",
+    "lint": "tsc --noEmit && eslint src/ --ext .ts,.tsx --quiet",
+    "test": "vitest --run"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.26.9",
+    "@babel/preset-env": "^7.26.9",
+    "@babel/preset-typescript": "^7.26.0",
+    "@eslint/js": "^9.19.0",
+    "${INTEGRATION_SDK_LIB_NAME}": "^{{integrationSdkVersion}}",
+    "${CUSTOM_PACKAGE_CLI_LIB_NAME}": "^{{packageCliVersion}}",
+    "eslint": "^9.19.0",
+    "globals": "^15.14.0",
+    "typescript": "^5.7.2",
+    "typescript-eslint": "^8.22.0",
+    "vitest": "^3.0.4"
+  }
+}
+`;

package/dist/package/commands.js

@@ -0,0 +1,5 @@
+export function registerPackageOptions(command) {
+    command
+        .option("--package-dir <packageDirPath>", "путь до директории с файлами пакета", "package")
+        .option("--package-manifest <manifestPath>", "путь до файла манифеста пакета", "package/manifest.json");
+}

package/dist/package/configs/webpack/buildPackage.js

@@ -1,23 +1,24 @@
 import { __awaiter } from "tslib";
 import ZipPlugin from "zip-webpack-plugin";
 import RemovePlugin from "remove-files-webpack-plugin";
-import CopyWebpackPlugin from "copy-webpack-plugin";
+import CopyWebpackPlugin, {} from "copy-webpack-plugin";
 import { JsonModifyWebpackPlugin } from "@infomaximum/json-modify-webpack-plugin";
-import { isExist, removeServiceFieldsForDevelopment, systemRequire, } from "../../../utils.js";
+import { compact, isExist, removeServiceFieldsForDevelopment, systemRequire, } from "../../../utils.js";
 import { BUILD_ARCHIVE_EXT, DEV_POSTFIX, MANIFEST_REG_EXP, } from "../../../const.js";
 import { assertSimple } from "@infomaximum/assert";
 const packageFilename = "main.js";
-export const getPackageBuildConfig = (_a) => __awaiter(void 0, [_a], void 0, function* ({ mode, PATHS, isBuildDevMode, entityArchivePath, }) {
+export const getPackageBuildConfig = (_a) => __awaiter(void 0, [_a], void 0, function* ({ mode, PATHS, isBuildDevMode, entityArchivePath, copyFiles = [], }) {
     const entityVersion = systemRequire(PATHS.appPackageJson).version;
     const manifestPackageName = systemRequire(PATHS.packageManifestPath).name;
     let entityPackageName = `${manifestPackageName}_${entityVersion}`;
     if (isBuildDevMode)
         entityPackageName += DEV_POSTFIX;
     assertSimple(yield isExist(PATHS.packageManifestPath), `File ${PATHS.packageManifestPath} not found`);
-    assertSimple(yield isExist(entityArchivePath), `File ${entityArchivePath} not found`);
+    entityArchivePath &&
+        assertSimple(yield isExist(entityArchivePath), `File ${entityArchivePath} not found`);
     return {
         mode,
-        entry: [PATHS.packageManifestPath, entityArchivePath],
+        entry: compact([PATHS.packageManifestPath, entityArchivePath]),
         output: {
             path: PATHS.appBuildPath,
             filename: packageFilename,
@@ -43,7 +44,7 @@ export const getPackageBuildConfig = (_a) => __awaiter(void 0, [_a], void 0, fun
         },
         plugins: [
             new CopyWebpackPlugin({
-                patterns: [{ from: PATHS.packagePath }],
+                patterns: [{ from: PATHS.packagePath }, ...copyFiles],
             }),
             new RemovePlugin({
                 after: {

package/dist/package/packagePaths.js

@@ -1,6 +1,6 @@
 import { _resolveApp, generateGlobalPaths } from "../paths.js";
-export function generatePackagePaths({ packageDir, packageManifest, buildDirPath, }) {
-    const globalPaths = generateGlobalPaths({ buildDirPath });
+export function generatePackagePaths({ packageDir, packageManifest, buildDir, }) {
+    const globalPaths = generateGlobalPaths({ buildDir });
     const resolveApp = _resolveApp();
     const packagePath = resolveApp(packageDir);
     return Object.assign(Object.assign({}, globalPaths), { packagePath, packageDirPath: resolveApp(packageDir), packageManifestPath: resolveApp(packageManifest) });

package/dist/package/scripts/actions.js

@@ -0,0 +1,36 @@
+import { AVAILABLE_LANGUAGES, MANIFEST_JSON_FILE_NAME } from "../../const.js";
+import { capitalizeFirstLetter } from "../../utils.js";
+import { GET_CHANGELOG_MD, GET_DOC_MD } from "../templates/additionalFiles.js";
+import { PACKAGE_ICON_TEMPLATE } from "../templates/packageIcon.js";
+import { PACKAGE_MANIFEST_TEMPLATE } from "../templates/packageManifest.js";
+export const getPackageActions = ({ packageType }) => {
+    const packageIconName = capitalizeFirstLetter(packageType);
+    return [
+        {
+            type: "add",
+            path: `package/${MANIFEST_JSON_FILE_NAME}`,
+            template: PACKAGE_MANIFEST_TEMPLATE,
+            data: {
+                packageIconName,
+                packageType: packageType,
+            },
+        },
+        {
+            type: "add",
+            path: `package/resources/${packageIconName}.svg`,
+            template: PACKAGE_ICON_TEMPLATE,
+        },
+        ...AVAILABLE_LANGUAGES.flatMap((language) => [
+            {
+                type: "add",
+                path: `package/${language}/doc.md`,
+                template: GET_DOC_MD(language),
+            },
+            {
+                type: "add",
+                path: `package/${language}/changelog.md`,
+                template: GET_CHANGELOG_MD(language),
+            },
+        ]),
+    ];
+};

package/dist/package/templates/packageManifest.js

@@ -4,8 +4,8 @@ import { capitalizeHelperName } from "../../plopHelpers.js";
 export const PACKAGE_MANIFEST_TEMPLATE = `\
 {
   "$schema": "../node_modules/${CUSTOM_PACKAGE_CLI_LIB_NAME}/schemas/packageManifestSchema.json",
-  "manifest_version": "1",
-  "min_version_platform": "1.0.0.0",
+  "manifest_version": "2",
+  "min_version_platform": "1.0.0.x",
   "author": "{{author}}",
   "guid": "${randomUUID()}",
   "type": "{{packageType}}",

package/dist/paths.js

@@ -26,11 +26,11 @@ export const generateIndexPath = (entryPath) => {
     process.exit(1);
 };
 export const generateGlobalPaths = (args) => {
-    const { cwd, buildDirPath } = args || {};
+    const { cwd, buildDir } = args || {};
     const resolveApp = _resolveApp(cwd);
     return {
         appPath: resolveApp("."),
-        appBuildPath: resolveApp(buildDirPath),
+        appBuildPath: resolveApp(buildDir),
         appPackageJson: resolveApp("package.json"),
         appTsConfig: resolveApp("tsconfig.json"),
         appNodeModules: resolveApp("node_modules"),

package/dist/plopHelpers.js

@@ -1,6 +1,43 @@
-import { capitalizeFirstLetter } from "./utils.js";
+import { __awaiter } from "tslib";
+import path from "node:path";
+import nodePlop from "node-plop";
+import { capitalizeFirstLetter, spawnCommand } from "./utils.js";
+import { prompts } from "./package/scripts/prompts.js";
 const capitalizeHelperName = "capitalize";
 const addCommonHelpers = (plop) => {
     plop.setHelper(capitalizeHelperName, capitalizeFirstLetter);
 };
 export { capitalizeHelperName, addCommonHelpers };
+export const runInitEntityScript = (_a) => __awaiter(void 0, [_a], void 0, function* ({ entity, dirName, actions, }) {
+    const createPath = path.join(process.cwd(), dirName);
+    const plop = yield nodePlop(undefined, {
+        destBasePath: createPath,
+        force: false,
+    });
+    addCommonHelpers(plop);
+    const generateEntityGeneratorName = `${entity}-generate`;
+    plop.setGenerator(generateEntityGeneratorName, {
+        prompts,
+        actions,
+    });
+    const initGenerator = plop.getGenerator(generateEntityGeneratorName);
+    const answers = (yield initGenerator.runPrompts());
+    yield initGenerator.runActions(answers);
+    const packageManager = answers.packageManager;
+    try {
+        yield spawnCommand(packageManager, ["install"], {
+            cwd: createPath,
+        });
+    }
+    catch (error) {
+        console.error(error);
+    }
+    try {
+        yield spawnCommand("git", ["init", "-b", "develop"], {
+            cwd: createPath,
+        });
+    }
+    catch (error) {
+        console.error(error);
+    }
+});

package/dist/types.js

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

package/dist/utils.js

@@ -5,6 +5,7 @@ import { spawn, exec } from "node:child_process";
 import util from "node:util";
 import Module from "node:module";
 import { MANIFEST_SERVICE_FIELDS_FOR_DEVELOPMENT } from "./const.js";
+import webpack, {} from "webpack";
 const execPromise = util.promisify(exec);
 export const isExist = (entityPath) => __awaiter(void 0, void 0, void 0, function* () {
     try {
@@ -61,3 +62,25 @@ export function removeServiceFieldsForDevelopment(obj) {
     });
 }
 export const compact = (items) => items.filter(Boolean);
+export function runWebpackBuild(config) {
+    const compiler = webpack(config);
+    return new Promise((res, rej) => {
+        compiler.run((err, stats) => handleWebpackCallback(err, stats, res, rej));
+    });
+}
+export function handleWebpackCallback(err, stats, okCb, errCb) {
+    if (err) {
+        console.error(err.stack || err);
+        if (err === null || err === void 0 ? void 0 : err.details) {
+            console.error(err.details);
+        }
+        errCb === null || errCb === void 0 ? void 0 : errCb();
+        return;
+    }
+    stats &&
+        console.log(stats.toString({
+            chunks: false,
+            colors: true,
+        }));
+    okCb === null || okCb === void 0 ? void 0 : okCb();
+}

package/dist/widget/commands/common.js

@@ -1,12 +1,12 @@
 import chalk from "chalk";
 import { assertSimple } from "@infomaximum/assert";
 import { DEFAULT_BUILD_DIR_NAME } from "../../const.js";
+import { registerPackageOptions, } from "../../package/commands.js";
 export function registerCommonOption(command) {
+    registerPackageOptions(command);
     command
         .option("--entry <path>", "путь до entrypoint")
         .option("--assets-dir <assetsDirPath>", "путь до директории с ресурсами виджета, которые будут перенесены в архив с виджетом")
-        .option("--package-manifest <manifestPath>", "путь до файла манифеста пакета")
-        .option("--package-dir <packageDirPath>", "путь до директории с файлами пакета")
         .option("--widget-manifest <manifestPath>", "путь до файла манифеста виджета");
 }
 export function configMergeWithOptionsCommon(config, options) {

package/dist/widget/commands/init.js

@@ -1,9 +1,15 @@
-import { runInitWidget } from "../scripts/init/init.js";
+import { __awaiter } from "tslib";
+import { runInitEntityScript } from "../../plopHelpers.js";
+import { getInitWidgetActions } from "../scripts/init/actions.js";
 export const registerWidgetInitCommand = (widgetCommand) => {
     const widgetInitCommand = widgetCommand.command("init <project-directory>");
     widgetInitCommand
         .description("Инициализация проекта виджета")
-        .action((dirName) => {
-        runInitWidget(dirName);
-    });
+        .action((dirName) => __awaiter(void 0, void 0, void 0, function* () {
+        runInitEntityScript({
+            dirName,
+            entity: "widget",
+            actions: yield getInitWidgetActions(),
+        });
+    }));
 };

package/dist/widget/scripts/build.js

@@ -1,5 +1,5 @@
 import { __awaiter } from "tslib";
-import webpack, {} from "webpack";
+import {} from "webpack";
 import {} from "../../paths.js";
 import { getPackageBuildConfig } from "../../package/configs/webpack/buildPackage.js";
 import { merge } from "webpack-merge";
@@ -13,6 +13,7 @@ import { WIDGET_ARCHIVE_FULL_NAME } from "../const.js";
 import { generateWidgetPaths } from "../widgetPaths.js";
 import { generatePackagePaths } from "../../package/packagePaths.js";
 import { checkLatestLibsVersion } from "../utils.js";
+import { runWebpackBuild } from "../../utils.js";
 export const runBuild = (args) => __awaiter(void 0, void 0, void 0, function* () {
     const mode = "production";
     const { buildDir, host, port, dev: isBuildDevMode, packageDir, packageManifest, } = args;
@@ -42,12 +43,12 @@ export const runBuild = (args) => __awaiter(void 0, void 0, void 0, function* ()
     const widgetConfig = merge(configSections);
     const widgetArchivePath = path.resolve(WIDGET_PATHS.appBuildPath, WIDGET_ARCHIVE_FULL_NAME);
     try {
-        yield build(widgetConfig);
+        yield runWebpackBuild(widgetConfig);
         console.log("");
-        yield build(yield getPackageBuildConfig({
+        yield runWebpackBuild(yield getPackageBuildConfig({
             mode,
             PATHS: generatePackagePaths({
-                buildDirPath: buildDir,
+                buildDir,
                 packageDir,
                 packageManifest,
             }),
@@ -62,23 +63,3 @@ export const runBuild = (args) => __awaiter(void 0, void 0, void 0, function* ()
         process.exit(1);
     }
 });
-function build(config) {
-    const compiler = webpack(config);
-    return new Promise((res, rej) => {
-        compiler.run((err, stats) => {
-            if (err) {
-                console.error(err.stack || err);
-                if (err === null || err === void 0 ? void 0 : err.details) {
-                    console.error(err.details);
-                }
-                rej();
-            }
-            stats &&
-                console.log(stats === null || stats === void 0 ? void 0 : stats.toString({
-                    chunks: false,
-                    colors: true,
-                }));
-            res();
-        });
-    });
-}

package/dist/widget/scripts/init/actions.js

@@ -15,7 +15,6 @@ import { WIDGET_BABEL_CONFIG, WIDGET_ESLINTIGNORE, WIDGET_ESLINTRC, WIDGET_GITIG
 import { WIDGET_PACKAGE_JSON_TEMPLATE } from "../../templates/widgetPackageJson.js";
 import { WIDGET_SDK_LIB_NAME } from "../../const.js";
 import { WIDGET_RC_CONFIG } from "../../templates/widgetRCConfig.js";
-const addInitActions = (basePath, plop) => { };
 const actions = ({ widgetSDKVersion, packageCliVersion }) => {
     const packageIconName = "Widget";
     return [
@@ -123,8 +122,7 @@ const actions = ({ widgetSDKVersion, packageCliVersion }) => {
         },
     ];
 };
-const getInitWidgetActions = (basePath, plop) => __awaiter(void 0, void 0, void 0, function* () {
-    addInitActions(basePath, plop);
+const getInitWidgetActions = () => __awaiter(void 0, void 0, void 0, function* () {
     const [packageCliVersion, widgetSDKVersion] = yield Promise.all([
         getLatestVersionOfLibrary(CUSTOM_PACKAGE_CLI_LIB_NAME),
         getLatestVersionOfLibrary(WIDGET_SDK_LIB_NAME),

package/dist/widget/scripts/release/release.js

@@ -39,7 +39,7 @@ export const runReleaseWidget = (options) => __awaiter(void 0, void 0, void 0, f
     const { first, dryRun } = options;
     const config = getConfigFromFile();
     const globalPaths = generateGlobalPaths({
-        buildDirPath: (_a = config === null || config === void 0 ? void 0 : config.buildDir) !== null && _a !== void 0 ? _a : DEFAULT_BUILD_DIR_NAME,
+        buildDir: (_a = config === null || config === void 0 ? void 0 : config.buildDir) !== null && _a !== void 0 ? _a : DEFAULT_BUILD_DIR_NAME,
     });
     const changelogFile = path.resolve(globalPaths.appPath, "CHANGELOG.md");
     const isFirstRelease = first || !(yield isExist(changelogFile));

package/dist/widget/templates/src/definition/definition.js

@@ -5,9 +5,6 @@ import type {
   IFillSettings,
   IGroupSettings,
   IPanelDescriptionCreator,
-  IWidgetDimension,
-  IWidgetDimensionHierarchy,
-  IWidgetMeasure,
 } from "${WIDGET_SDK_LIB_NAME}";
 import { fillSettings, type WidgetSettings } from "./settings";
 import { createPanelDescription } from "./panel";
@@ -20,13 +17,7 @@ export class Definition implements IDefinition<WidgetSettings, IGroupSettings> {
 
   public fillSettings: IFillSettings<WidgetSettings> = fillSettings;
 
-  public getDimensions(
-    settings: WidgetSettings
-  ): (IWidgetDimension | IWidgetDimensionHierarchy)[] {
-    return [];
-  }
-
-  public getMeasures(settings: WidgetSettings): IWidgetMeasure[] {
+  getLocalMigrateVersions(): string[] {
     return [];
   }
 }

package/dist/widget/templates/src/widgetIndex.js

@@ -49,5 +49,5 @@ class CustomWidget implements IWidget<WidgetSettings> {
   }
 }
 
-window.im.widget.defineWidget(manifest.uuid, CustomWidget, { manifest });
+window.im.widget.defineWidget(manifest.uuid, CustomWidget);
 `;

package/dist/widget/widgetPaths.js

@@ -2,7 +2,7 @@ import path from "node:path";
 import { _resolveApp, generateGlobalPaths, generateIndexPath, } from "../paths.js";
 const resolveApp = _resolveApp();
 export function generateWidgetPaths({ entry, assetsDir, widgetManifest, buildDir, }) {
-    const globalPaths = generateGlobalPaths({ buildDirPath: buildDir });
+    const globalPaths = generateGlobalPaths({ buildDir });
     return Object.assign(Object.assign({}, globalPaths), { get moduleIndex() {
             return generateIndexPath(entry);
         }, widgetManifestJsonPath: resolveApp(widgetManifest), widgetResourcesPath: assetsDir ? resolveApp(assetsDir) : null, widgetResourcesDirName: assetsDir ? path.basename(assetsDir) : null, widgetBuildDirPath: resolveApp(buildDir) });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@infomaximum/package-cli",
-  "version": "2.11.0",
+  "version": "2.12.0-rc.1",
   "exports": "./dist/index.js",
   "type": "module",
   "license": "Apache-2.0",

package/schemas/packageManifestSchema.json

@@ -21,7 +21,7 @@
       "title": "Имя пакета"
     },
     "type": {
-      "enum": ["widget", "application", "workspace"]
+      "enum": ["widget", "application", "workspace", "integration"]
     },
     "version": {
       "type": "string",

package/dist/widget/scripts/init/generators.js

@@ -1,15 +0,0 @@
-import { __awaiter } from "tslib";
-import { getInitWidgetActions } from "./actions.js";
-import { prompts } from "./prompts.js";
-import { addCommonHelpers } from "../../../plopHelpers.js";
-const generateWidgetGeneratorName = "widget-generate";
-const getInitWidgetGenerator = (basePath, plop) => __awaiter(void 0, void 0, void 0, function* () {
-    addCommonHelpers(plop);
-    const actions = yield getInitWidgetActions(basePath, plop);
-    plop.setGenerator(generateWidgetGeneratorName, {
-        prompts,
-        actions,
-    });
-    return plop.getGenerator(generateWidgetGeneratorName);
-});
-export { getInitWidgetGenerator };

package/dist/widget/scripts/init/init.js

@@ -1,33 +0,0 @@
-import { __awaiter } from "tslib";
-import path from "node:path";
-import nodePlop from "node-plop";
-import { getInitWidgetGenerator } from "./generators.js";
-import { spawnCommand } from "../../../utils.js";
-const runInitWidget = (dirName) => __awaiter(void 0, void 0, void 0, function* () {
-    const createPath = path.join(process.cwd(), dirName);
-    const plop = yield nodePlop(undefined, {
-        destBasePath: createPath,
-        force: false,
-    });
-    const initGenerator = yield getInitWidgetGenerator(createPath, plop);
-    const answers = (yield initGenerator.runPrompts());
-    yield initGenerator.runActions(answers);
-    const packageManager = answers.packageManager;
-    try {
-        yield spawnCommand(packageManager, ["install"], {
-            cwd: createPath,
-        });
-    }
-    catch (error) {
-        console.error(error);
-    }
-    try {
-        yield spawnCommand("git", ["init", "-b", "develop"], {
-            cwd: createPath,
-        });
-    }
-    catch (error) {
-        console.error(error);
-    }
-});
-export { runInitWidget };