@dcloudio/uni-cli-utils 3.0.0-alpha-3090920231127001

package/dist/easycom/context.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { throttle } from 'throttle-debounce';
+import type fs from 'node:fs';
+import type { ComponentInfo, Options, ResolvedOptions } from './types';
+export declare class EasyComContext {
+    options: ResolvedOptions;
+    private _componentPaths;
+    private _componentMap;
+    constructor(rawOptions: Options);
+    setupWatcher(watcher: fs.FSWatcher): void;
+    removeComponents(paths: string | string[]): boolean;
+    addComponents(paths: string | string[], parseTag: (filename: string) => string): boolean;
+    onUpdate(_path: string): void;
+    private updateComponentNameMap;
+    _searched: boolean;
+    searchGlob(): void;
+    searchComponents(): void;
+    searchCustomComponents(): void;
+    _generateDeclaration(removeUnused?: boolean): Promise<void>;
+    generateDeclaration: throttle<(removeUnused?: boolean) => Promise<void>>;
+    get componentMap(): Record<string, ComponentInfo>;
+}

package/dist/easycom/context.js

@@ -0,0 +1,146 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EasyComContext = void 0;
+const throttle_debounce_1 = require("throttle-debounce");
+const debug_1 = __importDefault(require("debug"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const declaration_1 = require("./declaration");
+const options_1 = require("./options");
+const utils_1 = require("./utils");
+const utils_2 = require("../utils");
+const debug = {
+    components: (0, debug_1.default)('easycom:context:components'),
+    search: (0, debug_1.default)('easycom:context:search'),
+    declaration: (0, debug_1.default)('easycom:declaration'),
+};
+class EasyComContext {
+    constructor(rawOptions) {
+        this._componentPaths = new Map();
+        this._componentMap = {};
+        this._searched = false;
+        this.options = (0, options_1.resolveOptions)(rawOptions);
+        this.generateDeclaration = (0, throttle_debounce_1.throttle)(500, this._generateDeclaration.bind(this), { noLeading: false });
+    }
+    setupWatcher(watcher) {
+        const { globs, customGlobs } = this.options;
+        watcher.on('unlink', (path) => {
+            if ((0, utils_1.matchGlobs)(path, globs)) {
+                path = (0, utils_2.slash)(path);
+                this.removeComponents(path);
+                this.onUpdate(path);
+            }
+            else {
+                customGlobs.find((custom) => {
+                    if ((0, utils_1.matchGlobs)(path, [custom.glob])) {
+                        path = (0, utils_2.slash)(path);
+                        this.removeComponents(path);
+                        this.onUpdate(path);
+                        return true;
+                    }
+                });
+            }
+        });
+        watcher.on('add', (path) => {
+            if ((0, utils_1.matchGlobs)(path, globs)) {
+                path = (0, utils_2.slash)(path);
+                this.addComponents(path, utils_1.parseTag);
+                this.onUpdate(path);
+            }
+            else {
+                customGlobs.find((custom) => {
+                    if ((0, utils_1.matchGlobs)(path, [custom.glob])) {
+                        path = (0, utils_2.slash)(path);
+                        this.addComponents(path, custom.parseTag);
+                        this.onUpdate(path);
+                        return true;
+                    }
+                });
+            }
+        });
+    }
+    removeComponents(paths) {
+        debug.components('remove', paths);
+        const size = this._componentPaths.size;
+        (0, utils_2.toArray)(paths).forEach((p) => this._componentPaths.delete(p));
+        if (this._componentPaths.size !== size) {
+            this.updateComponentNameMap();
+            return true;
+        }
+        return false;
+    }
+    addComponents(paths, parseTag) {
+        debug.components('add', paths);
+        const size = this._componentPaths.size;
+        (0, utils_2.toArray)(paths).forEach((p) => this._componentPaths.set(p, parseTag(p)));
+        if (this._componentPaths.size !== size) {
+            this.updateComponentNameMap();
+            return true;
+        }
+        return false;
+    }
+    onUpdate(_path) {
+        this.generateDeclaration();
+    }
+    updateComponentNameMap() {
+        this._componentMap = {};
+        this._componentPaths.forEach((tag, path) => {
+            if (this._componentMap[tag]) {
+                if ((0, utils_1.removeExtname)(path) === (0, utils_1.removeExtname)(this._componentMap[tag].from)) {
+                    // 仅后缀不同，如.uvue|.vue|.nvue
+                    return;
+                }
+                if (!this.options.allowOverrides) {
+                    console.warn(`[easycom] component "${tag}"(${path}) has naming conflicts with other components, ignored.`);
+                    return;
+                }
+            }
+            this._componentMap[tag] = {
+                as: tag,
+                from: path,
+            };
+        });
+    }
+    searchGlob() {
+        if (this._searched)
+            return;
+        this.searchComponents();
+        debug.search(this._componentMap);
+        this._searched = true;
+    }
+    searchComponents() {
+        debug.search(`started with: [${this.options.globs.join(', ')}]`);
+        const root = this.options.inputDir;
+        const files = fast_glob_1.default.sync(this.options.globs, {
+            ignore: ['node_modules', 'unpackage', 'uniCloud-*', 'static'],
+            onlyFiles: true,
+            cwd: root,
+            absolute: true,
+        });
+        debug.search(`${files.length} components found.`);
+        this.addComponents(files, utils_1.parseTag);
+        this.searchCustomComponents();
+    }
+    searchCustomComponents() {
+        debug.search(`started with: [${this.options.customGlobs.join(', ')}]`);
+        const root = this.options.inputDir;
+        this.options.customGlobs.forEach((custom) => {
+            const files = fast_glob_1.default.sync(custom.glob, {
+                onlyFiles: true,
+                cwd: root,
+                absolute: true,
+            });
+            debug.search(`${files.length} components found.`);
+            this.addComponents(files, custom.parseTag);
+        });
+    }
+    _generateDeclaration(removeUnused = false) {
+        return (0, declaration_1.writeDeclaration)(this, this.options.dts, removeUnused);
+    }
+    get componentMap() {
+        return this._componentMap;
+    }
+}
+exports.EasyComContext = EasyComContext;

package/dist/easycom/declaration.d.ts

@@ -0,0 +1,16 @@
+import type { EasyComContext } from './context';
+import { ComponentInfo } from './types';
+export declare function parseDeclaration(code: string): DeclarationImports | undefined;
+/**
+ * Converts array of `ComponentInfo` to an import map
+ *
+ * `{ name: "typeof import(path)[importName]", ... }`
+ */
+export declare function stringifyComponentsInfo(filepath: string, components: ComponentInfo[]): Record<string, string>;
+export interface DeclarationImports {
+    component: Record<string, string>;
+}
+export declare function getDeclarationImports(ctx: EasyComContext, filepath: string): DeclarationImports | undefined;
+export declare function stringifyDeclarationImports(imports: Record<string, string>): string[];
+export declare function getDeclaration(ctx: EasyComContext, filepath: string, originalImports?: DeclarationImports): string | undefined;
+export declare function writeDeclaration(ctx: EasyComContext, filepath: string, removeUnused?: boolean): Promise<void>;

package/dist/easycom/declaration.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeDeclaration = exports.getDeclaration = exports.stringifyDeclarationImports = exports.getDeclarationImports = exports.stringifyComponentsInfo = exports.parseDeclaration = void 0;
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
+const promises_1 = require("node:fs/promises");
+const utils_1 = require("../utils");
+const multilineCommentsRE = /\/\*.*?\*\//gms;
+const singlelineCommentsRE = /\/\/.*$/gm;
+function extractImports(code) {
+    return Object.fromEntries(Array.from(code.matchAll(/['"]?([^\s'"]+)['"]?\s*:\s*(.+?)[,;\n]/g)).map((i) => [i[1], i[2]]));
+}
+function parseDeclaration(code) {
+    if (!code)
+        return;
+    code = code.replace(multilineCommentsRE, '').replace(singlelineCommentsRE, '');
+    const imports = {
+        component: {},
+    };
+    const componentDeclaration = /export\s+interface\s+GlobalComponents\s*{(.*?)}/s.exec(code)?.[0];
+    if (componentDeclaration)
+        imports.component = extractImports(componentDeclaration);
+    return imports;
+}
+exports.parseDeclaration = parseDeclaration;
+/**
+ * Converts `ComponentInfo` to an array
+ *
+ * `[name, "typeof import(path)[importName]"]`
+ */
+function stringifyComponentInfo(filepath, { from: path, as: name, name: importName }) {
+    if (!name)
+        return undefined;
+    const related = (0, node_path_1.isAbsolute)(path)
+        ? `./${(0, node_path_1.relative)((0, node_path_1.dirname)(filepath), path)}`
+        : path;
+    const entry = `typeof import('${(0, utils_1.slash)(related)}')['${importName || 'default'}']`;
+    return [name, entry];
+}
+/**
+ * Converts array of `ComponentInfo` to an import map
+ *
+ * `{ name: "typeof import(path)[importName]", ... }`
+ */
+function stringifyComponentsInfo(filepath, components) {
+    return Object.fromEntries(components
+        .map((info) => stringifyComponentInfo(filepath, info))
+        .filter(utils_1.notNullish));
+}
+exports.stringifyComponentsInfo = stringifyComponentsInfo;
+function getDeclarationImports(ctx, filepath) {
+    const component = stringifyComponentsInfo(filepath, [
+        ...Object.values(ctx.componentMap),
+    ]);
+    if (Object.keys(component).length === 0)
+        return;
+    return { component };
+}
+exports.getDeclarationImports = getDeclarationImports;
+function stringifyDeclarationImports(imports) {
+    return Object.entries(imports)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([name, v]) => {
+        if (!/^\w+$/.test(name))
+            name = `'${name}'`;
+        return `${name}: ${v}`;
+    });
+}
+exports.stringifyDeclarationImports = stringifyDeclarationImports;
+function getDeclaration(ctx, filepath, originalImports) {
+    const imports = getDeclarationImports(ctx, filepath);
+    if (!imports)
+        return;
+    const declarations = {
+        component: stringifyDeclarationImports({
+            ...originalImports?.component,
+            ...imports.component,
+        }),
+    };
+    const head = `export {}
+
+declare module 'vue' {`;
+    let code = `/* eslint-disable */
+/* prettier-ignore */
+// @ts-nocheck
+${head}`;
+    if (Object.keys(declarations.component).length > 0) {
+        code += `
+  export interface GlobalComponents {
+    ${declarations.component.join('\n    ')}
+  }`;
+    }
+    code += '\n}\n';
+    return code;
+}
+exports.getDeclaration = getDeclaration;
+async function writeFile(filePath, content) {
+    await (0, promises_1.mkdir)((0, node_path_1.dirname)(filePath), { recursive: true });
+    return await (0, promises_1.writeFile)(filePath, content, 'utf-8');
+}
+async function writeDeclaration(ctx, filepath, removeUnused = false) {
+    const originalContent = (0, node_fs_1.existsSync)(filepath)
+        ? await (0, promises_1.readFile)(filepath, 'utf-8')
+        : '';
+    const originalImports = removeUnused
+        ? undefined
+        : parseDeclaration(originalContent);
+    const code = getDeclaration(ctx, filepath, originalImports);
+    if (!code)
+        return;
+    if (code !== originalContent)
+        await writeFile(filepath, code);
+}
+exports.writeDeclaration = writeDeclaration;

package/dist/easycom/index.d.ts

@@ -0,0 +1 @@
+export { EasyComContext } from './context';

package/dist/easycom/index.js

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

package/dist/easycom/options.d.ts

@@ -0,0 +1,4 @@
+import type { EasyComCustom, Options, ResolvedOptions } from './types';
+export declare function resolveOptions(rawOptions: Options): ResolvedOptions;
+export declare function parseGlob(glob: string, inputDir: string): string;
+export declare function parseEasyComTag(tag: string, path: string, inputDir: string): EasyComCustom;

package/dist/easycom/options.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEasyComTag = exports.parseGlob = exports.resolveOptions = void 0;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const jsonc_parser_1 = require("jsonc-parser");
+const resolve_1 = require("resolve");
+const utils_1 = require("../utils");
+const AUTO_SCAN_GLOBS = [
+    'components/**/*.{vue,uvue,nvue}',
+    'uni_modules/*/components/**/*.{vue,uvue,nvue}',
+];
+function normalizeGlob(str, replace = '*') {
+    // 将所有 $0、$1 等占位符，替换为*
+    return str.replace(/\$\d+/g, replace);
+}
+function resolveOptions(rawOptions) {
+    const options = {
+        dts: (0, node_path_1.resolve)(rawOptions.outputDir, '../.dts/easycom.d.ts'),
+        allowOverrides: false,
+        ...rawOptions,
+        ...initGlobs(rawOptions.inputDir),
+    };
+    return options;
+}
+exports.resolveOptions = resolveOptions;
+function initGlobs(inputDir) {
+    const customGlobs = [];
+    let autoScan = true;
+    const pagesJsonFilename = (0, node_path_1.resolve)(inputDir, 'pages.json');
+    if ((0, node_fs_1.existsSync)(pagesJsonFilename)) {
+        const pagesJson = (0, jsonc_parser_1.parse)((0, node_fs_1.readFileSync)(pagesJsonFilename, 'utf8'));
+        const easyComOptions = pagesJson?.easycom;
+        if (easyComOptions) {
+            if (easyComOptions.autoscan === false) {
+                autoScan = false;
+            }
+            const customOptions = easyComOptions.custom;
+            if (customOptions) {
+                Object.keys(customOptions).forEach((tag) => {
+                    customGlobs.push(parseEasyComTag(tag, customOptions[tag], inputDir));
+                });
+            }
+        }
+    }
+    return { globs: autoScan ? AUTO_SCAN_GLOBS : [], customGlobs };
+}
+function parseGlob(glob, inputDir) {
+    const parts = glob.split('/');
+    const index = parts.findIndex((part) => part.includes('*'));
+    let globParts = [];
+    if (index > -1) {
+        globParts = parts.splice(index);
+    }
+    const popParts = [];
+    function findPath(parts) {
+        if (parts.length === 0) {
+            return glob;
+        }
+        const checkPath = parts.join('/');
+        try {
+            const resolvedPath = (0, resolve_1.sync)(checkPath, {
+                basedir: inputDir,
+                packageFilter(pkg) {
+                    if (!pkg.main) {
+                        pkg.main = 'package.json';
+                    }
+                    return pkg;
+                },
+                // preserveSymlinks: false,
+            });
+            return (0, utils_1.slash)((0, node_path_1.join)((0, node_path_1.dirname)(resolvedPath), ...popParts, ...globParts));
+        }
+        catch (err) {
+            const part = parts.pop();
+            if (part) {
+                popParts.push(part);
+            }
+            return findPath(parts);
+        }
+    }
+    return findPath(parts);
+}
+exports.parseGlob = parseGlob;
+function parseEasyComTag(tag, path, inputDir) {
+    let glob = normalizeGlob(path);
+    // 项目根目录
+    if (glob.startsWith('@/')) {
+        glob = glob.slice(2);
+    }
+    else {
+        // npm
+        glob = parseGlob(glob, inputDir);
+    }
+    const mappings = [];
+    const matches = path.match(/\$\d+/g);
+    if (matches) {
+        matches.forEach((m, index) => {
+            mappings.push([index + 1, parseInt(m.slice(1))]);
+        });
+    }
+    /**
+     * 映射关系
+     * @dcloudio/uni-ui/lib/uni-$1/uni-$1.vue 会被转换为 @dcloudio/uni-ui/lib/uni-(.*)/uni-(.*).vue
+     * [[1, 1],[2, 1]]
+     * 第一个元素是转换后的(.*)索引位置，第二个元素是转换前的索引位置
+     */
+    const regex = normalizeGlob(path, '(.*)');
+    return {
+        tag,
+        path,
+        glob,
+        parseTag(filename) {
+            const matches = filename.match(regex);
+            if (matches) {
+                let newTag = replaceWithIndexes(tag);
+                for (let i = mappings.length - 1; i >= 0; i--) {
+                    const mapping = mappings[i];
+                    newTag = newTag.replace('$' + mapping[1], matches[mapping[0]]);
+                }
+                return newTag;
+            }
+            return '';
+        },
+    };
+}
+exports.parseEasyComTag = parseEasyComTag;
+function replaceWithIndexes(pattern) {
+    // 匹配(.*)的正则表达式
+    const regex = /\(\.\*\)/g;
+    let index = 1;
+    // 替换所有的(.*)为$+索引的形式
+    let replaced = pattern.replace(regex, function () {
+        return '$' + index++;
+    });
+    if (replaced.startsWith('^')) {
+        replaced = replaced.slice(1);
+    }
+    if (replaced.endsWith('$')) {
+        replaced = replaced.slice(0, -1);
+    }
+    return replaced;
+}

package/dist/easycom/types.d.ts

@@ -0,0 +1,45 @@
+export interface Options {
+    inputDir: string;
+    outputDir: string;
+    dts?: string;
+    allowOverrides?: boolean;
+}
+export interface ResolvedOptions extends Required<Options> {
+    globs: string[];
+    customGlobs: EasyComCustom[];
+}
+interface ImportInfo {
+    as?: string;
+    name?: string;
+    from: string;
+}
+type SideEffectsInfo = (ImportInfo | string)[] | ImportInfo | string | undefined;
+export interface ComponentInfo extends ImportInfo {
+    sideEffects?: SideEffectsInfo;
+}
+export interface EasyComOptions {
+    autoscan?: boolean;
+    custom?: Record<string, string>;
+}
+export interface EasyComCustom {
+    /**
+     * 组件标签名（正则）
+     * ^uni-(.*)
+     */
+    tag: string;
+    /**
+     * 组件路径
+     * @dcloudio/uni-ui/lib/uni-$1/uni-$1.vue
+     */
+    path: string;
+    /**
+     * 绝对路径的glob
+     */
+    glob: string;
+    /**
+     * 根据文件解析组件名
+     * @param filename
+     */
+    parseTag(filename: string): string;
+}
+export {};

package/dist/easycom/types.js

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

package/dist/easycom/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function matchGlobs(filepath: string, globs: string[]): boolean;
+export declare function parseTag(filename: string): string;
+export declare function removeExtname(filename: string): string;

package/dist/easycom/utils.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeExtname = exports.parseTag = exports.matchGlobs = void 0;
+const minimatch_1 = require("minimatch");
+const utils_1 = require("../utils");
+const node_path_1 = require("node:path");
+function matchGlobs(filepath, globs) {
+    for (const glob of globs) {
+        if ((0, minimatch_1.minimatch)((0, utils_1.slash)(filepath), glob))
+            return true;
+    }
+    return false;
+}
+exports.matchGlobs = matchGlobs;
+function parseTag(filename) {
+    return removeExtname((0, node_path_1.basename)(filename));
+}
+exports.parseTag = parseTag;
+function removeExtname(filename) {
+    return filename.replace(/\.\w+$/, '');
+}
+exports.removeExtname = removeExtname;

package/dist/index.d.ts

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

package/dist/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("./easycom"), exports);

package/dist/utils.d.ts

@@ -0,0 +1,9 @@
+export declare function notNullish<T>(v: T | null | undefined): v is NonNullable<T>;
+export declare function slash(str: string): string;
+export type Nullable<T> = T | null | undefined;
+export type Arrayable<T> = T | Array<T>;
+export declare function toArray<T>(array?: Nullable<Arrayable<T>>): Array<T>;
+export declare function pascalCase(str: string): string;
+export declare function camelCase(str: string): string;
+export declare function kebabCase(key: string): string;
+export declare function capitalize(str: string): string;

package/dist/utils.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capitalize = exports.kebabCase = exports.camelCase = exports.pascalCase = exports.toArray = exports.slash = exports.notNullish = void 0;
+function notNullish(v) {
+    return v != null;
+}
+exports.notNullish = notNullish;
+function slash(str) {
+    return str.replace(/\\/g, '/');
+}
+exports.slash = slash;
+function toArray(array) {
+    array = array ?? [];
+    return Array.isArray(array) ? array : [array];
+}
+exports.toArray = toArray;
+function pascalCase(str) {
+    return capitalize(camelCase(str));
+}
+exports.pascalCase = pascalCase;
+function camelCase(str) {
+    return str.replace(/-(\w)/g, (_, c) => (c ? c.toUpperCase() : ''));
+}
+exports.camelCase = camelCase;
+function kebabCase(key) {
+    const result = key.replace(/([A-Z])/g, ' $1').trim();
+    return result.split(' ').join('-').toLowerCase();
+}
+exports.kebabCase = kebabCase;
+function capitalize(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+exports.capitalize = capitalize;

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@dcloudio/uni-cli-utils",
+  "version": "3.0.0-alpha-3090920231127001",
+  "description": "@dcloudio/uni-cli-utils",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "lib"
+  ],
+  "engines": {
+    "node": "^14.18.0 || >=16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dcloudio/uni-app.git",
+    "directory": "packages/uni-cli-utils"
+  },
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/dcloudio/uni-app/issues"
+  },
+  "dependencies": {
+    "debug": "^4.3.3",
+    "fast-glob": "^3.2.11",
+    "jsonc-parser": "^3.2.0",
+    "minimatch": "^9.0.3",
+    "resolve": "^1.22.1",
+    "throttle-debounce": "^5.0.0"
+  },
+  "devDependencies": {
+    "@types/debug": "^4.1.7",
+    "@types/resolve": "^1.20.2",
+    "@types/throttle-debounce": "^5.0.2"
+  }
+}