@conarti/eslint-plugin-feature-sliced 1.0.3

package/dist/lib/shared/is-object.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = void 0;
+function isObject(target) {
+    return (typeof target === 'object' || typeof target === 'function') && (target !== null);
+}
+exports.isObject = isObject;

package/dist/lib/shared/is-undefined.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUndefined = void 0;
+function isUndefined(target) {
+    return target === undefined;
+}
+exports.isUndefined = isUndefined;

package/dist/rules/absolute-relative/config.js

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

package/dist/rules/absolute-relative/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_lib_1 = require("../../lib/rule-lib");
+const model_1 = require("./model");
+exports.default = (0, rule_lib_1.createRule)({
+    name: 'absolute-relative',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Checks for absolute and relative paths',
+            recommended: false,
+        },
+        messages: {
+            ["must-be-relative-path"]: 'There must be relative paths',
+            ["must-be-absolute-path"]: 'There must be absolute paths',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    ignoreInFilesPatterns: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            ignoreInFilesPatterns: [],
+        },
+    ],
+    create(context, optionsWithDefault) {
+        return {
+            ImportDeclaration(node) {
+                (0, model_1.validateAndReport)(node, context, optionsWithDefault);
+            },
+            ImportExpression(node) {
+                (0, model_1.validateAndReport)(node, context, optionsWithDefault);
+            },
+            ExportAllDeclaration(node) {
+                (0, model_1.validateAndReport)(node, context, optionsWithDefault, { needCheckForAbsolute: false });
+            },
+            ExportNamedDeclaration(node) {
+                (0, model_1.validateAndReport)(node, context, optionsWithDefault, { needCheckForAbsolute: false });
+            },
+        };
+    },
+});

package/dist/rules/absolute-relative/model/errors-lib.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportShouldBeAbsolute = exports.reportShouldBeRelative = void 0;
+function reportShouldBeRelative(node, context) {
+    context.report({
+        node: node.source,
+        messageId: "must-be-relative-path",
+    });
+}
+exports.reportShouldBeRelative = reportShouldBeRelative;
+function reportShouldBeAbsolute(node, context) {
+    context.report({
+        node: node.source,
+        messageId: "must-be-absolute-path",
+    });
+}
+exports.reportShouldBeAbsolute = reportShouldBeAbsolute;

package/dist/rules/absolute-relative/model/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAndReport = void 0;
+var validate_and_report_1 = require("./validate-and-report");
+Object.defineProperty(exports, "validateAndReport", { enumerable: true, get: function () { return validate_and_report_1.validateAndReport; } });

package/dist/rules/absolute-relative/model/should-be-absolute.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldBeAbsolute = void 0;
+const path_lib_1 = require("../../../lib/path-lib");
+function shouldBeAbsolute(pathsInfo) {
+    const { normalizedTargetPath, fsdPartsOfTarget, fsdPartsOfCurrentFile, hasUnknownLayers, } = pathsInfo;
+    const isAbsolute = !(0, path_lib_1.isPathRelative)(normalizedTargetPath);
+    if (isAbsolute) {
+        return false;
+    }
+    if (hasUnknownLayers) {
+        return false;
+    }
+    return fsdPartsOfCurrentFile.layer !== fsdPartsOfTarget.layer;
+}
+exports.shouldBeAbsolute = shouldBeAbsolute;

package/dist/rules/absolute-relative/model/should-be-relative.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldBeRelative = void 0;
+const path_lib_1 = require("../../../lib/path-lib");
+function shouldBeRelative(pathsInfo) {
+    const { validatedFeatureSlicedPartsOfCurrentFile, normalizedTargetPath, isSameLayerWithoutSlices, isSameLayer, isSameSlice, } = pathsInfo;
+    const isRelative = (0, path_lib_1.isPathRelative)(normalizedTargetPath);
+    if (isRelative) {
+        return false;
+    }
+    const isImportToLayerPublicApi = validatedFeatureSlicedPartsOfCurrentFile.hasNotSlice && isSameLayer;
+    if (isImportToLayerPublicApi) {
+        return true;
+    }
+    if (isSameLayerWithoutSlices) {
+        return true;
+    }
+    const isSameLayerAndSlice = isSameLayer && isSameSlice;
+    return isSameLayerAndSlice;
+}
+exports.shouldBeRelative = shouldBeRelative;

package/dist/rules/absolute-relative/model/validate-and-report.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAndReport = void 0;
+const fsd_lib_1 = require("../../../lib/fsd-lib");
+const rule_lib_1 = require("../../../lib/rule-lib");
+const errors_lib_1 = require("./errors-lib");
+const should_be_absolute_1 = require("./should-be-absolute");
+const should_be_relative_1 = require("./should-be-relative");
+function validateAndReport(node, context, optionsWithDefault, options = { needCheckForAbsolute: true }) {
+    if (!(0, rule_lib_1.canValidate)(node)) {
+        return;
+    }
+    if ((0, rule_lib_1.isIgnoredCurrentFile)(context, optionsWithDefault)) {
+        return;
+    }
+    const pathsInfo = (0, fsd_lib_1.extractPathsInfo)(node, context);
+    if ((0, should_be_relative_1.shouldBeRelative)(pathsInfo)) {
+        (0, errors_lib_1.reportShouldBeRelative)(node, context);
+    }
+    if (options.needCheckForAbsolute && (0, should_be_absolute_1.shouldBeAbsolute)(pathsInfo)) {
+        (0, errors_lib_1.reportShouldBeAbsolute)(node, context);
+    }
+}
+exports.validateAndReport = validateAndReport;

package/dist/rules/layers-slices/config.js

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

package/dist/rules/layers-slices/index.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_lib_1 = require("../../lib/rule-lib");
+const model_1 = require("./model");
+exports.default = (0, rule_lib_1.createRule)({
+    name: 'layers-slices',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Checks layer imports',
+            recommended: false,
+        },
+        messages: {
+            ["can-not-import"]: 'You cannot import layer "{{ importLayer }}" into "{{ currentFileLayer }}" (shared -> entities -> features -> widgets -> pages -> processes -> app)',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    allowTypeImports: {
+                        type: 'boolean',
+                    },
+                    ignorePatterns: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                    ignoreInFilesPatterns: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            allowTypeImports: true,
+            ignorePatterns: [],
+            ignoreInFilesPatterns: [],
+        },
+    ],
+    create(context, optionsWithDefault) {
+        return {
+            ImportDeclaration(node) {
+                (0, model_1.validateAndReport)(node, context, optionsWithDefault);
+            },
+            ImportExpression(node) {
+                (0, model_1.validateAndReport)(node, context, optionsWithDefault);
+            },
+        };
+    },
+});

package/dist/rules/layers-slices/model/can-import-layer.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canImportLayer = void 0;
+const fsd_lib_1 = require("../../../lib/fsd-lib");
+const rule_lib_1 = require("../../../lib/rule-lib");
+function canImportLayer(pathsInfo, node, ruleOptions) {
+    const { fsdPartsOfTarget, fsdPartsOfCurrentFile, isSameSlice, isSameLayerWithoutSlices, hasUnknownLayers, } = pathsInfo;
+    if (hasUnknownLayers) {
+        return true;
+    }
+    const { allowTypeImports } = ruleOptions;
+    const isType = (0, rule_lib_1.isNodeType)(node);
+    const isTypeAndAllowedToImport = allowTypeImports && isType;
+    const importLayerOrder = (0, fsd_lib_1.getLayerWeight)(fsdPartsOfTarget.layer);
+    const currentFileLayerOrder = (0, fsd_lib_1.getLayerWeight)(fsdPartsOfCurrentFile.layer);
+    const isImportLayerBelowCurrent = currentFileLayerOrder > importLayerOrder;
+    return isSameSlice
+        || isTypeAndAllowedToImport
+        || isSameLayerWithoutSlices
+        || isImportLayerBelowCurrent;
+}
+exports.canImportLayer = canImportLayer;

package/dist/rules/layers-slices/model/errors-lib.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportCanNotImportLayer = void 0;
+function reportCanNotImportLayer(context, node, pathsInfo) {
+    context.report({
+        node: node.source,
+        messageId: "can-not-import",
+        data: {
+            importLayer: pathsInfo.fsdPartsOfTarget.layer,
+            currentFileLayer: pathsInfo.fsdPartsOfCurrentFile.layer,
+        },
+    });
+}
+exports.reportCanNotImportLayer = reportCanNotImportLayer;

package/dist/rules/layers-slices/model/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAndReport = void 0;
+var validate_and_report_1 = require("./validate-and-report");
+Object.defineProperty(exports, "validateAndReport", { enumerable: true, get: function () { return validate_and_report_1.validateAndReport; } });

package/dist/rules/layers-slices/model/validate-and-report.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAndReport = void 0;
+const fsd_lib_1 = require("../../../lib/fsd-lib");
+const rule_lib_1 = require("../../../lib/rule-lib");
+const can_import_layer_1 = require("./can-import-layer");
+const errors_lib_1 = require("./errors-lib");
+function validateAndReport(node, context, optionsWithDefault) {
+    if (!(0, rule_lib_1.canValidate)(node)) {
+        return;
+    }
+    const pathsInfo = (0, fsd_lib_1.extractPathsInfo)(node, context);
+    const userDefinedRuleOptions = (0, rule_lib_1.extractRuleOptions)(optionsWithDefault);
+    const isIgnoredTargetPath = (0, rule_lib_1.isIgnored)(pathsInfo.targetPath, userDefinedRuleOptions.ignorePatterns);
+    if (isIgnoredTargetPath || (0, rule_lib_1.isIgnoredCurrentFile)(context, optionsWithDefault)) {
+        return;
+    }
+    if (!(0, can_import_layer_1.canImportLayer)(pathsInfo, node, userDefinedRuleOptions)) {
+        (0, errors_lib_1.reportCanNotImportLayer)(context, node, pathsInfo);
+    }
+}
+exports.validateAndReport = validateAndReport;

package/dist/rules/public-api/config.js

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

package/dist/rules/public-api/index.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rule_lib_1 = require("../../lib/rule-lib");
+const model_1 = require("./model");
+const validate_and_report_program_1 = require("./model/validate-and-report-program");
+exports.default = (0, rule_lib_1.createRule)({
+    name: 'public-api',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Check for module imports from public api',
+            recommended: false,
+        },
+        hasSuggestions: true,
+        messages: {
+            ["should-be-from-public-api"]: 'Absolute imports are only allowed from public api ("{{ fixedPath }}")',
+            ["remove-suggestion"]: 'Remove the "{{ valueToRemove }}"',
+            ["layers-public-api-not-allowed"]: 'The layer public API is not allowed. It harms both architecturally and practically (code splitting)',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    level: {
+                        enum: [
+                            "segments",
+                            "slices",
+                        ],
+                    },
+                    ignoreInFilesPatterns: {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                        },
+                    },
+                },
+            },
+        ],
+    },
+    defaultOptions: [
+        {
+            level: "slices",
+            ignoreInFilesPatterns: [],
+        },
+    ],
+    create(context, optionsWithDefault) {
+        return {
+            ImportDeclaration(node) {
+                (0, model_1.validateAndReport)(node, context, optionsWithDefault);
+            },
+            ImportExpression(node) {
+                (0, model_1.validateAndReport)(node, context, optionsWithDefault);
+            },
+            ExportAllDeclaration(node) {
+                (0, model_1.validateAndReport)(node, context, optionsWithDefault);
+            },
+            ExportNamedDeclaration(node) {
+                (0, model_1.validateAndReport)(node, context, optionsWithDefault);
+            },
+            Program(node) {
+                (0, validate_and_report_program_1.validateAndReportProgram)(node, context, optionsWithDefault);
+            },
+        };
+    },
+});

package/dist/rules/public-api/model/convert-to-public-api.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertToPublicApi = void 0;
+const shared_1 = require("../../../lib/shared");
+function addSlashToStart(targetPath) {
+    if ((0, shared_1.isNull)(targetPath)) {
+        return '';
+    }
+    return `/${targetPath}`;
+}
+function extractValueToRemove(pathsInfo) {
+    const { isSameSlice, fsdPartsOfTarget, } = pathsInfo;
+    if (isSameSlice) {
+        return fsdPartsOfTarget.segmentFiles;
+    }
+    return `${fsdPartsOfTarget.segment}${addSlashToStart(fsdPartsOfTarget.segmentFiles)}`;
+}
+function convertToPublicApi(pathsInfo) {
+    const { normalizedTargetPath } = pathsInfo;
+    const valueToRemove = extractValueToRemove(pathsInfo);
+    const publicApiPath = normalizedTargetPath.replace(`/${valueToRemove}`, '');
+    return [publicApiPath, valueToRemove];
+}
+exports.convertToPublicApi = convertToPublicApi;

package/dist/rules/public-api/model/errors-lib.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportLayersPublicApiNotAllowed = exports.reportShouldBeFromPublicApi = void 0;
+const fsd_lib_1 = require("../../../lib/fsd-lib");
+const rule_lib_1 = require("../../../lib/rule-lib");
+const convert_to_public_api_1 = require("./convert-to-public-api");
+function reportShouldBeFromPublicApi(node, context) {
+    const pathsInfo = (0, fsd_lib_1.extractPathsInfo)(node, context);
+    const [fixedPath, valueToRemove] = (0, convert_to_public_api_1.convertToPublicApi)(pathsInfo);
+    context.report({
+        node: node.source,
+        messageId: "should-be-from-public-api",
+        data: {
+            fixedPath,
+        },
+        suggest: [
+            {
+                messageId: "remove-suggestion",
+                data: {
+                    valueToRemove,
+                },
+                fix: (fixer) => fixer.replaceTextRange((0, rule_lib_1.getSourceRangeWithoutQuotes)(node.source.range), fixedPath),
+            },
+        ],
+    });
+}
+exports.reportShouldBeFromPublicApi = reportShouldBeFromPublicApi;
+function reportLayersPublicApiNotAllowed(node, context) {
+    context.report({
+        node,
+        messageId: "layers-public-api-not-allowed",
+    });
+}
+exports.reportLayersPublicApiNotAllowed = reportLayersPublicApiNotAllowed;

package/dist/rules/public-api/model/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAndReport = void 0;
+var validate_and_report_1 = require("./validate-and-report");
+Object.defineProperty(exports, "validateAndReport", { enumerable: true, get: function () { return validate_and_report_1.validateAndReport; } });

package/dist/rules/public-api/model/is-index-file.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIndexFile = void 0;
+function isIndexFile(segmentFiles) {
+    return /^index\.\w+/i.test(segmentFiles);
+}
+exports.isIndexFile = isIndexFile;

package/dist/rules/public-api/model/is-layer-public-api.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLayerPublicApi = void 0;
+const picomatch_1 = __importDefault(require("picomatch"));
+const fsd_lib_1 = require("../../../lib/fsd-lib");
+const rule_lib_1 = require("../../../lib/rule-lib");
+const shared_1 = require("../../../lib/shared");
+function isLayerPublicApi(context) {
+    const normalizedCurrentFilePath = (0, rule_lib_1.extractCurrentFilePath)(context);
+    const cwd = (0, rule_lib_1.extractCwd)(context);
+    const layer = (0, fsd_lib_1.extractLayer)(normalizedCurrentFilePath, cwd);
+    if ((0, shared_1.isNull)(layer)) {
+        return false;
+    }
+    const matcher = (0, picomatch_1.default)([
+        `**/${layer}/index.*`,
+    ]);
+    return matcher(normalizedCurrentFilePath);
+}
+exports.isLayerPublicApi = isLayerPublicApi;

package/dist/rules/public-api/model/is-segments-public-api.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSegmentsPublicApi = void 0;
+const is_index_file_1 = require("./is-index-file");
+function isSegmentsPublicApi(pathsInfo) {
+    const { fsdPartsOfTarget, validatedFeatureSlicedPartsOfTarget, isSameSegment, } = pathsInfo;
+    const isSegmentPublicApi = validatedFeatureSlicedPartsOfTarget.hasNotSegmentFiles
+        || (0, is_index_file_1.isIndexFile)(fsdPartsOfTarget.segmentFiles);
+    return isSameSegment || isSegmentPublicApi;
+}
+exports.isSegmentsPublicApi = isSegmentsPublicApi;

package/dist/rules/public-api/model/is-slice-public-api.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSlicePublicApi = void 0;
+function isSlicePublicApi(pathsInfo) {
+    return pathsInfo.validatedFeatureSlicedPartsOfTarget.hasNotSegment;
+}
+exports.isSlicePublicApi = isSlicePublicApi;

package/dist/rules/public-api/model/should-be-from-public-api.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldBeFromPublicApi = void 0;
+const fsd_lib_1 = require("../../../lib/fsd-lib");
+const rule_lib_1 = require("../../../lib/rule-lib");
+const is_segments_public_api_1 = require("./is-segments-public-api");
+const is_slice_public_api_1 = require("./is-slice-public-api");
+function shouldBeFromSlicePublicApi(pathsInfo) {
+    const isFromAnotherSlice = !pathsInfo.isSameSlice;
+    return isFromAnotherSlice && !(0, is_slice_public_api_1.isSlicePublicApi)(pathsInfo);
+}
+function shouldBeFromSegmentsPublicApi(pathsInfo, validateOptions) {
+    const needValidateSegments = validateOptions.level === "segments";
+    return needValidateSegments && !(0, is_segments_public_api_1.isSegmentsPublicApi)(pathsInfo);
+}
+function shouldBeFromPublicApi(node, context, optionsWithDefault) {
+    const pathsInfo = (0, fsd_lib_1.extractPathsInfo)(node, context);
+    const ruleOptions = (0, rule_lib_1.extractRuleOptions)(optionsWithDefault);
+    return shouldBeFromSlicePublicApi(pathsInfo) || shouldBeFromSegmentsPublicApi(pathsInfo, ruleOptions);
+}
+exports.shouldBeFromPublicApi = shouldBeFromPublicApi;

package/dist/rules/public-api/model/validate-and-report-program.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAndReportProgram = void 0;
+const rule_lib_1 = require("../../../lib/rule-lib");
+const errors_lib_1 = require("./errors-lib");
+const is_layer_public_api_1 = require("./is-layer-public-api");
+function validateAndReportProgram(node, context, optionsWithDefault) {
+    if ((0, rule_lib_1.isIgnoredCurrentFile)(context, optionsWithDefault)) {
+        return;
+    }
+    if ((0, is_layer_public_api_1.isLayerPublicApi)(context)) {
+        (0, errors_lib_1.reportLayersPublicApiNotAllowed)(node, context);
+    }
+}
+exports.validateAndReportProgram = validateAndReportProgram;

package/dist/rules/public-api/model/validate-and-report.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateAndReport = void 0;
+const rule_lib_1 = require("../../../lib/rule-lib");
+const errors_lib_1 = require("./errors-lib");
+const should_be_from_public_api_1 = require("./should-be-from-public-api");
+function validateAndReport(node, context, optionsWithDefault) {
+    if (!(0, rule_lib_1.canValidate)(node)) {
+        return;
+    }
+    if ((0, rule_lib_1.isIgnoredCurrentFile)(context, optionsWithDefault)) {
+        return;
+    }
+    if ((0, should_be_from_public_api_1.shouldBeFromPublicApi)(node, context, optionsWithDefault)) {
+        (0, errors_lib_1.reportShouldBeFromPublicApi)(node, context);
+    }
+}
+exports.validateAndReport = validateAndReport;

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@conarti/eslint-plugin-feature-sliced",
+  "version": "1.0.3",
+  "description": "Feature-sliced design methodology plugin",
+  "repository": "https://github.com/conarti/eslint-plugin-fsd.git",
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "feature-sliced",
+    "feature-slices",
+    "feature-driven",
+    "feature-based"
+  ],
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
+  "author": "conarti",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./import-order": "./dist/configs/import-order/index.js"
+  },
+  "scripts": {
+    "clean": "rimraf ./dist",
+    "build": "npm run clean && tsc -p tsconfig.build.json",
+    "lint": "npm-run-all \"lint:*\"",
+    "lint:js": "eslint .",
+    "test": "vitest",
+    "test:ui": "vitest --ui --api 9527",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "publish:patch": "npm version patch && npm publish",
+    "publish:minor": "npm version minor && npm publish",
+    "publish:major": "npm version major && npm publish",
+    "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s",
+    "local-build": "node scripts/local-build.js",
+    "release": "node scripts/release.js",
+    "docs:dev": "vitepress dev docs",
+    "docs:build": "vitepress build docs",
+    "docs:preview": "vitepress preview docs"
+  },
+  "devDependencies": {
+    "@total-typescript/ts-reset": "^0.4.2",
+    "@tsconfig/node14": "^1.0.3",
+    "@types/eslint": "^8.40.2",
+    "@types/node": "^20.2.5",
+    "@types/picomatch": "^2.3.0",
+    "@typescript-eslint/eslint-plugin": "^5.59.9",
+    "@typescript-eslint/parser": "^5.53.0",
+    "@typescript-eslint/utils": "^5.59.9",
+    "@vitest/coverage-v8": "^0.32.0",
+    "@vitest/ui": "^0.32.0",
+    "conventional-changelog-cli": "^2.2.2",
+    "eslint": "^8.42.0",
+    "eslint-config-airbnb-base": "^15.0.0",
+    "eslint-import-resolver-typescript": "^3.5.5",
+    "eslint-plugin-eslint-plugin": "^5.0.0",
+    "eslint-plugin-filenames-simple": "^0.8.0",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-unused-imports": "^2.0.0",
+    "eslint-plugin-vitest": "^0.2.6",
+    "execa": "5.1.1",
+    "npm-run-all": "^4.1.5",
+    "picocolors": "^1.0.0",
+    "prompts": "^2.4.2",
+    "rimraf": "^5.0.1",
+    "semver": "^7.3.8",
+    "typescript": "^4.9.5",
+    "vitepress": "^1.0.0-alpha.64",
+    "vitest": "^0.32.0"
+  },
+  "engines": {
+    "node": "^14.17.0 || ^16.0.0 || >= 18.0.0"
+  },
+  "peerDependencies": {
+    "eslint": ">=7",
+    "eslint-plugin-import": ">=2.26"
+  },
+  "license": "ISC",
+  "dependencies": {
+    "picomatch": "^2.3.1"
+  }
+}