@cmtlyt/unplugin-shadcn-registry-generate 0.1.0

package/README.md

@@ -0,0 +1,52 @@
+# unplugin-shadcn-registry-generate
+
+生成 shadcn 的 registry 和对应的 registry-item
+
+## 使用
+
+创建 `shadcn-exports.json` 文件, 示例内容如下
+
+```json
+{
+  "$schema": "./node_modules/@cmtlyt/unplugin-shadcn-registry-generate",
+  "exports": [
+    { "path": "./src/atomic-functions/assert-never.ts" },
+    { "path": "./src/atomic-functions/sleep.ts" },
+    { "path": "./src/tools/allx.ts", "name": "promiseAllX", "description": "promiseAllX", "title": "promiseAllX" },
+    { "path": "./src/types/base.ts" }
+  ]
+}
+```
+
+在打包工具配置文件中补充如下内容, 以 rslib 为例
+
+```ts
+import { defineConfig } from '@rslib/core';
+import shadcnRegistryGenerator from '@cmtlyt/unplugin-shadcn-registry-generate';
+
+export default defineConfig({
+  lib: [
+    {
+      format: 'esm',
+      syntax: ['node 18'],
+      dts: true,
+      tools: {
+        rspack: {
+          plugins: [shadcnRegistryGenerator.rspack()]
+        },
+      },
+    },
+  ],
+});
+```
+
+然后执行 `npm run build` 即可
+
+## 提示
+
+name 生成规则如下
+
+- 文件名不为 index 使用文件名
+- 文件夹名
+
+所以 name 是可能会冲突的, 为了更好的控制 name 最好是手动配置 name

package/configuration-schema.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {
+    "exports": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": { "type": "string" },
+          "path": { "type": "string" },
+          "description": { "type": "string" },
+          "title": { "type": "string" },
+          "author": { "type": "string" }
+        },
+        "required": ["path"]
+      }
+    }
+  },
+  "required": ["exports"],
+  "uniqueItems": true,
+  "minItems": 1
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { ShadcnRegisterGeneratorOptions } from './types';
+declare const shadcnRegisterGenerator: import("unplugin").UnpluginInstance<ShadcnRegisterGeneratorOptions, boolean>;
+export default shadcnRegisterGenerator;

package/dist/index.js

@@ -0,0 +1,391 @@
+import { createUnplugin } from "unplugin";
+import node_fs from "node:fs";
+import node_path from "node:path";
+import { readTSConfig, resolvePackageJSON } from "pkg-types";
+import { createRequire } from "node:module";
+import { randomUUID } from "node:crypto";
+function initOuputDir(ctx) {
+    const { options } = ctx;
+    const { outputDir } = options;
+    if (!node_fs.existsSync(outputDir)) node_fs.mkdirSync(outputDir, {
+        recursive: true
+    });
+}
+function normalizeBasePath(basePath) {
+    if (basePath.endsWith('/')) return basePath;
+    return `${basePath}/`;
+}
+function normalizeOptions(options) {
+    if (!options.registryUrl) throw new Error('registryUrl is required');
+    return {
+        registryUrl: options.registryUrl,
+        outputDir: options.outputDir || './public/r',
+        basePath: normalizeBasePath(options.basePath || '~/'),
+        noRootRegistry: true === options.noRootRegistry
+    };
+}
+function readConfig(ctx) {
+    const configPath = node_path.join(ctx.baseDir, 'shadcn-exports.json');
+    if (!node_fs.existsSync(configPath)) return null;
+    return JSON.parse(node_fs.readFileSync(configPath, 'utf-8'));
+}
+async function initContext(ctx) {
+    ctx.baseDir = node_path.dirname(await resolvePackageJSON());
+    const config = await readConfig(ctx);
+    if (!config) console.warn('shadcn-exports.json not found');
+    ctx.config = config || {
+        exports: []
+    };
+    ctx.tsConfig = await readTSConfig(ctx.baseDir);
+}
+function createContext(options) {
+    return {
+        options: normalizeOptions(options),
+        baseDir: '',
+        config: null,
+        exports: null,
+        tsConfig: null,
+        runCtx: {
+            reqistrys: [],
+            dependenciesSet: null,
+            aliasMap: {}
+        }
+    };
+}
+function getNameFromPath(exportItem, ctx) {
+    if (node_fs.statSync(exportItem.path).isFile()) {
+        const baseName = node_path.basename(exportItem.path);
+        if (baseName.startsWith('index')) return node_path.basename(node_path.dirname(exportItem.path), ctx.baseDir);
+        return baseName.replace(/\.\w+$/, '');
+    }
+    return node_path.basename(exportItem.path, ctx.baseDir);
+}
+const fileRequire = createRequire(import.meta.url);
+function isNodeOrgModule(id) {
+    return id.startsWith('node:') || !id.includes('/');
+}
+function pathMatch(realPath, id, isFile) {
+    if (isFile) return realPath === id;
+    return id.startsWith(realPath) && !id.includes('node_modules');
+}
+function fileInWorkspace(filePath, ctx) {
+    return pathMatch(ctx.baseDir, filePath, false);
+}
+function extTry(filePath, _ctx) {
+    const exts = [
+        '.ts',
+        '.tsx',
+        '.js',
+        '.jsx',
+        '.cjs',
+        '.mjs',
+        '.vue'
+    ];
+    for(let i = 0; i < exts.length; i++){
+        const ext = exts[i];
+        const fullPath = `${filePath}${ext}`;
+        if (node_fs.existsSync(fullPath)) return fullPath;
+    }
+    if (node_fs.existsSync(`${filePath}/index.ts`)) return `${filePath}/index.ts`;
+    return filePath;
+}
+function tsPathsResolve(id, ctx, filePath) {
+    try {
+        const tempId = fileRequire.resolve(id);
+        if (node_path.isAbsolute(tempId)) return {
+            type: 'original',
+            originalId: id,
+            resolvedId: id
+        };
+    } catch  {}
+    if (isNodeOrgModule(id)) return {
+        type: 'original',
+        originalId: id,
+        resolvedId: id
+    };
+    const { paths, baseUrl } = ctx.tsConfig?.compilerOptions || {};
+    const fileDir = node_path.dirname(filePath);
+    if (!paths) return {
+        type: 'relative',
+        originalId: id,
+        resolvedId: extTry(node_path.resolve(fileDir, id), ctx)
+    };
+    const keys = Reflect.ownKeys(paths);
+    for(let i = 0; i < keys.length; i++){
+        const key = keys[i];
+        const value = paths[key][0].replace(/\*$/, '');
+        if (id === key) {
+            const resolvedId = extTry(node_path.resolve(baseUrl || ctx.baseDir, value), ctx);
+            return {
+                type: 'alias',
+                originalId: id,
+                resolvedId,
+                relativePath: node_path.relative(fileDir, resolvedId),
+                aliasPath: value
+            };
+        }
+        const keyWithoutStar = key.replace(/\*$/, '');
+        if (id.startsWith(keyWithoutStar)) {
+            const resolvedId = extTry(node_path.resolve(baseUrl || ctx.baseDir, id.replace(keyWithoutStar, value)), ctx);
+            return {
+                type: 'alias',
+                originalId: id,
+                resolvedId,
+                relativePath: node_path.relative(fileDir, resolvedId),
+                aliasPath: value
+            };
+        }
+    }
+    return {
+        type: 'relative',
+        originalId: id,
+        resolvedId: extTry(node_path.resolve(fileDir, id), ctx)
+    };
+}
+function getFileDependencies(filePath, fileContent, ctx, dependenciesSet, uuid) {
+    const dependencieRegexp = /import.*?from.*?(['"])(.*?)\1|import.*?(['"])(.*?)\3|import\(.*?(['"])(.*?)\5.*?\)|export.*?from.*?(['"])(.*?)\7/g;
+    const dependencies = [];
+    let match = dependencieRegexp.exec(fileContent);
+    while(null !== match){
+        const [, , id1, , id2, , id3, , id4] = match;
+        const id = id1 || id2 || id3 || id4;
+        try {
+            const { resolvedId, relativePath, type, ...resolveInfo } = tsPathsResolve(id, ctx, filePath);
+            if ('alias' === type && relativePath) ctx.runCtx.aliasMap[uuid].push({
+                ...resolveInfo,
+                relativePath,
+                resolvedId
+            });
+            if (dependenciesSet.has(resolvedId)) {
+                match = dependencieRegexp.exec(fileContent);
+                continue;
+            }
+            const depPath = fileRequire.resolve(resolvedId);
+            dependencies.push(...getFile(depPath, ctx, id, fileInWorkspace(depPath, ctx)));
+            dependenciesSet.add(depPath);
+        } catch (error) {
+            console.warn(error);
+        }
+        match = dependencieRegexp.exec(fileContent);
+    }
+    return dependencies;
+}
+function getFile(filePath, ctx, id, inWorkspace = true) {
+    const { runCtx, options } = ctx;
+    const { dependenciesSet } = runCtx;
+    if (dependenciesSet.has(filePath)) return [];
+    const relativePath = node_path.relative(ctx.baseDir, filePath);
+    const files = [];
+    const uuid = randomUUID();
+    const aliases = [];
+    ctx.runCtx.aliasMap[uuid] = aliases;
+    const fileContent = node_fs.readFileSync(filePath, 'utf-8');
+    if (inWorkspace) {
+        files.push({
+            uuid,
+            path: relativePath,
+            type: 'registry:file',
+            target: `${options.basePath}${node_path.relative(ctx.baseDir, filePath)}`,
+            fileType: 'workfile',
+            aliases,
+            fileContent
+        });
+        const deps = getFileDependencies(filePath, fileContent, ctx, dependenciesSet, uuid);
+        files.push(...deps);
+    } else {
+        const isDependency = filePath.includes('node_modules');
+        if (!isNodeOrgModule(filePath)) files.push({
+            uuid,
+            path: relativePath,
+            id,
+            fileType: isDependency ? 'dependency' : 'external',
+            aliases,
+            fileContent
+        });
+    }
+    return files;
+}
+function readDirFiles(realPath, files, ctx) {
+    node_fs.readdirSync(realPath).forEach((file)=>{
+        const filePath = node_path.join(realPath, file);
+        const isFile = node_fs.statSync(filePath).isFile();
+        if (isFile) return void files.push(...getFile(filePath, ctx));
+        readDirFiles(filePath, files, ctx);
+    });
+}
+function patchFileAndDeps(exportItem, ctx) {
+    const { extInfo, files, dependencies, registryDependencies } = exportItem;
+    ctx.runCtx.dependenciesSet = new Set();
+    if (extInfo.isFile) files.push(...getFile(exportItem.extInfo.realPath, ctx));
+    else readDirFiles(extInfo.realPath, files, ctx);
+    exportItem.files = files.filter((item)=>{
+        if ('workfile' === item.fileType) return true;
+        if ('registry' === item.fileType) {
+            registryDependencies.push(`./${item.id}.json`);
+            return false;
+        }
+        if ('dependency' === item.fileType) dependencies.push(item.id);
+        return false;
+    }).map((item)=>{
+        const { fileType: _, ...rest } = item;
+        return rest;
+    });
+    ctx.runCtx.dependenciesSet = null;
+}
+function resolveRegistryDependencieUrl(name, ctx) {
+    const { options } = ctx;
+    return `${options.registryUrl}/${name}.json`;
+}
+function registryItemOptimization(regItem, ctx) {
+    const { extInfo } = regItem;
+    const { fileMap } = extInfo;
+    const { reqistrys } = ctx.runCtx;
+    reqistrys.filter((item)=>{
+        if (item.name === regItem.name) return false;
+        if (item.extInfo.filePaths.some((filePath)=>!fileMap.has(filePath))) return false;
+        return true;
+    }).forEach((item)=>{
+        regItem.registryDependencies.push(resolveRegistryDependencieUrl(item.name, ctx));
+        item.extInfo.filePaths.forEach((filePath)=>{
+            fileMap.delete(filePath);
+        });
+    });
+    const files = Array.from(fileMap.values());
+    return {
+        ...regItem,
+        files
+    };
+}
+function clearExportsFields(ctx) {
+    const { exports } = ctx;
+    ctx.exports = exports.map((item)=>{
+        const { extInfo: _, ...otherItem } = item;
+        const files = otherItem.files.map((file)=>{
+            const { path: filePath, type, target } = file;
+            return {
+                path: filePath,
+                type,
+                target
+            };
+        });
+        return {
+            ...otherItem,
+            files
+        };
+    });
+}
+function filesSummary(item) {
+    const files = item.files;
+    const fileMap = new Map();
+    files.forEach((file)=>{
+        const { path: filePath } = file;
+        fileMap.set(filePath, file);
+    });
+    item.extInfo.filePaths = Array.from(fileMap.keys());
+    item.extInfo.fileMap = fileMap;
+}
+function generateExports(ctx) {
+    const { config } = ctx;
+    const { exports: _exports } = config;
+    const exports = _exports.map((item)=>{
+        const { path: _path, ...rest } = item;
+        const name = rest.name || getNameFromPath(item, ctx);
+        const { resolvedId: realPath } = tsPathsResolve(item.path, ctx, `${ctx.baseDir}/package.json`);
+        const isFile = node_fs.statSync(realPath).isFile();
+        const resolveId = fileRequire.resolve(realPath);
+        const registryItem = {
+            title: name,
+            name: name,
+            description: name,
+            registryDependencies: [],
+            dependencies: [],
+            files: [],
+            ...rest,
+            type: 'registry:item',
+            extInfo: {
+                realPath,
+                isFile,
+                resolveId
+            }
+        };
+        ctx.runCtx.reqistrys.push(registryItem);
+        return registryItem;
+    }).map((item)=>{
+        patchFileAndDeps(item, ctx);
+        filesSummary(item);
+        return item;
+    }).map((item)=>registryItemOptimization(item, ctx));
+    ctx.exports = exports;
+    return exports;
+}
+function generateRegistryJson(ctx) {
+    const { baseDir, options, config, exports } = ctx;
+    const { exports: _, $schema: __, ...otherConfig } = config;
+    const { outputDir, noRootRegistry } = options;
+    const registryJson = JSON.stringify({
+        $schema: 'https://ui.shadcn.com/schema/registry.json',
+        name: '',
+        homepage: '',
+        items: exports,
+        ...otherConfig
+    }, null, 2);
+    if (!noRootRegistry) node_fs.writeFileSync(node_path.join(baseDir, 'registry.json'), registryJson);
+    node_fs.writeFileSync(node_path.join(outputDir, 'registry.json'), registryJson);
+}
+function aliasTransformToRelative(ctx) {
+    const { exports } = ctx;
+    exports.forEach((item)=>{
+        const { files } = item;
+        files.forEach((file)=>{
+            const { aliases } = file;
+            if (0 === aliases.length) return;
+            aliases.forEach((alias)=>{
+                const { relativePath, originalId } = alias;
+                file.fileContent = file.fileContent.replace(new RegExp(originalId, 'g'), relativePath);
+            });
+        });
+    });
+}
+function generateRegistryItemJson(regItem) {
+    const { files: _files, extInfo: _, ...otherConfig } = regItem;
+    const files = _files.map((item)=>{
+        const { path: fromPath, type, target, fileContent } = item;
+        return {
+            path: fromPath,
+            type,
+            target,
+            content: fileContent
+        };
+    });
+    return {
+        $schema: 'https://ui.shadcn.com/schema/registry-item.json',
+        ...otherConfig,
+        files
+    };
+}
+function generateRegistryItemJsons(ctx) {
+    const { exports, options } = ctx;
+    const { outputDir } = options;
+    aliasTransformToRelative(ctx);
+    exports.forEach((item)=>{
+        const ouputPath = node_path.join(outputDir, `${item.name}.json`);
+        const regJson = generateRegistryItemJson(item);
+        node_fs.writeFileSync(ouputPath, JSON.stringify(regJson, null, 2));
+    });
+}
+const shadcnRegisterGenerator = createUnplugin((options)=>{
+    const ctx = createContext(options);
+    return {
+        name: 'unplugin-shadcn-register-generator',
+        async buildStart () {
+            await initContext(ctx);
+            generateExports(ctx);
+            initOuputDir(ctx);
+            generateRegistryItemJsons(ctx);
+            clearExportsFields(ctx);
+            generateRegistryJson(ctx);
+        }
+    };
+});
+const src = shadcnRegisterGenerator;
+export default src;

package/dist/types/index.d.ts

@@ -0,0 +1,38 @@
+import type { TSConfig } from 'pkg-types';
+export interface ShadcnRegisterGeneratorOptions {
+    /**
+     * registry 仓库地址
+     */
+    registryUrl: string;
+    /**
+     * 输出目录
+     * @default './public/r'
+     */
+    outputDir?: string;
+    /**
+     * 基础 target 路径
+     * @default '~/'
+     */
+    basePath?: string;
+    /**
+     * 是否不生成根目录的 registry.json
+     * @default false
+     */
+    noRootRegistry?: boolean;
+}
+export interface Context {
+    options: Required<ShadcnRegisterGeneratorOptions>;
+    baseDir: string;
+    config: any;
+    exports: any;
+    tsConfig: TSConfig;
+    runCtx: {
+        reqistrys: any[];
+        dependenciesSet: Set<string>;
+        aliasMap: Record<string, Array<{
+            originalId: string;
+            relativePath: string;
+            resolvedId: string;
+        }>>;
+    };
+}

package/dist/utils/base.d.ts

@@ -0,0 +1,3 @@
+import type { Context, ShadcnRegisterGeneratorOptions } from '../types';
+export declare function initOuputDir(ctx: Context): void;
+export declare function normalizeOptions(options: ShadcnRegisterGeneratorOptions): Required<ShadcnRegisterGeneratorOptions>;

package/dist/utils/context.d.ts

@@ -0,0 +1,14 @@
+import type { Context, ShadcnRegisterGeneratorOptions } from '../types';
+export declare function initContext(ctx: Context): Promise<void>;
+export declare function createContext(options: ShadcnRegisterGeneratorOptions): {
+    options: Required<ShadcnRegisterGeneratorOptions>;
+    baseDir: string;
+    config: null;
+    exports: null;
+    tsConfig: any;
+    runCtx: {
+        reqistrys: any[];
+        dependenciesSet: any;
+        aliasMap: {};
+    };
+};

package/dist/utils/generate-exports/clear-exports-fields.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../../types';
+export declare function clearExportsFields(ctx: Context): void;

package/dist/utils/generate-exports/get-file.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../../types';
+export declare function getFile(filePath: string, ctx: Context, id?: string, inWorkspace?: boolean): any[];

package/dist/utils/generate-exports/index.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from '../../types';
+export * from './clear-exports-fields';
+export declare function generateExports(ctx: Context): any;

package/dist/utils/generate-exports/patch-file-and-deps.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../../types';
+export declare function patchFileAndDeps(exportItem: any, ctx: Context): void;

package/dist/utils/generate-exports/registry-item-optimization.d.ts

@@ -0,0 +1,3 @@
+import type { Context } from '../../types';
+export declare function resolveRegistryDependencieUrl(name: string, ctx: Context): string;
+export declare function registryItemOptimization(regItem: any, ctx: Context): any;

package/dist/utils/generate-shadcn-registry/index.d.ts

@@ -0,0 +1,2 @@
+export * from './registry';
+export * from './registry-item';

package/dist/utils/generate-shadcn-registry/registry-item.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../../types';
+export declare function generateRegistryItemJsons(ctx: Context): void;

package/dist/utils/generate-shadcn-registry/registry.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../../types';
+export declare function generateRegistryJson(ctx: Context): void;

package/dist/utils/get-name-from-path.d.ts

@@ -0,0 +1,2 @@
+import type { Context } from '../types';
+export declare function getNameFromPath(exportItem: any, ctx: Context): string;

package/dist/utils/index.d.ts

@@ -0,0 +1,8 @@
+export * from './base';
+export * from './context';
+export * from './generate-exports';
+export * from './generate-shadcn-registry';
+export * from './get-name-from-path';
+export * from './require';
+export * from './ts-paths-resolve';
+export * from './verify';

package/dist/utils/require.d.ts

@@ -0,0 +1 @@
+export declare const fileRequire: NodeJS.Require;

package/dist/utils/ts-paths-resolve.d.ts

@@ -0,0 +1,14 @@
+import type { Context } from '../types';
+export declare function tsPathsResolve(id: string, ctx: Context, filePath: string): {
+    type: string;
+    originalId: string;
+    resolvedId: string;
+    relativePath?: undefined;
+    aliasPath?: undefined;
+} | {
+    type: string;
+    originalId: string;
+    resolvedId: string;
+    relativePath: string;
+    aliasPath: any;
+};

package/dist/utils/verify.d.ts

@@ -0,0 +1,4 @@
+import type { Context } from '../types';
+export declare function isNodeOrgModule(id: string): boolean;
+export declare function pathMatch(realPath: string, id: string, isFile: boolean): boolean;
+export declare function fileInWorkspace(filePath: string, ctx: Context): boolean;

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "@cmtlyt/unplugin-shadcn-registry-generate",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "configuration-schema.json"
+  ],
+  "dependencies": {
+    "pkg-types": "^2.3.0",
+    "unplugin": "^2.3.11"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.3.8",
+    "@commitlint/cli": "^20.3.1",
+    "@commitlint/config-conventional": "^20.3.1",
+    "@rslib/core": "^0.19.2",
+    "@types/node": "^24.10.7",
+    "esno": "^4.8.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.7",
+    "typescript": "^5.9.3"
+  },
+  "private": false,
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": ">=18.0.0"
+    },
+    "packageManager": {
+      "name": "pnpm"
+    }
+  },
+  "homepage": "https://github.com/cmtlyt/unplugin-shadcn-registry-generate#readme",
+  "bugs": {
+    "url": "https://github.com/cmtlyt/unplugin-shadcn-registry-generate/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cmtlyt/unplugin-shadcn-registry-generate.git"
+  },
+  "keywords": [
+    "cmtlyt",
+    "unplugin",
+    "shadcn",
+    "shadcn-plugin",
+    "generate-registry"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "check": "biome check --write",
+    "dev": "rslib build --watch",
+    "format": "biome format --write"
+  }
+}