@fontmin-plugin/plugin 0.1.0 → 0.1.1

package/dist/index.cjs

@@ -0,0 +1,174 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.tsx
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default,
+  frameworksConfig: () => frameworksConfig,
+  handleImport: () => handleImport,
+  unplugin: () => unplugin,
+  unpluginFactory: () => unpluginFactory
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_path = __toESM(require("path"), 1);
+var import_unplugin = require("unplugin");
+
+// src/core.ts
+var import_node_util = require("util");
+var import_fontmin = __toESM(require("fontmin"), 1);
+var import_radash = require("radash");
+var presets = {
+  numbers: "0123456789",
+  lowerCase: "abcdefghijklmnopqrstuvwxyz",
+  upperCase: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  symbols: "!@#$%^&*()_+-=[]{}|;:,.<>?`~",
+  allBasic: String.fromCharCode.apply(void 0, (0, import_radash.list)(33, 126))
+};
+var classNameCounter = 0;
+var generateClassName = () => {
+  classNameCounter++;
+  return `fontmin_${classNameCounter}_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+};
+var loadAndProcessFont = async (config) => {
+  const text = `${config.presets?.map((preset) => presets[preset] || "").join("") || ""}${config.glyph || ""}`;
+  if (!text || !config.fontPath) {
+    console.error(
+      new Error("No text or font path to process, Please check your config")
+    );
+    return "";
+  }
+  const fontmin = new import_fontmin.default().src(config.fontPath).use(import_fontmin.default.glyph({ text, hinting: false }));
+  const runAsync = (0, import_node_util.promisify)(fontmin.run.bind(fontmin));
+  const files = await runAsync();
+  if (!files?.[0]) {
+    console.error(new Error("Font processing failed"));
+    return "";
+  }
+  const buffer = files[0].contents;
+  return buffer.toString("base64");
+};
+async function createFontStyle(config) {
+  try {
+    const className = generateClassName();
+    const base64 = await loadAndProcessFont(config);
+    return {
+      fontClassName: className,
+      fontBase64: base64
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to create font style: ${message}`);
+  }
+}
+
+// src/index.tsx
+var importerPrefix = "@fontmin-plugin/";
+var frameworksConfig = {
+  react: {
+    prefix: `${importerPrefix}react/`,
+    generateModule: (fontVarString) => `
+          import { createElement } from 'react';
+          import FontminText from '@fontmin-plugin/react';
+          const fontConfig = ${fontVarString};
+          export default (props) => createElement(FontminText, { ...fontConfig, ...props });
+        `
+  },
+  vue: {
+    prefix: `${importerPrefix}vue/`,
+    generateModule: (fontVarString) => `
+          import { h } from 'vue';
+          import FontminText from '@fontmin-plugin/vue';
+          const fontConfig = ${fontVarString};
+          export default h(FontminText, { ...fontConfig });
+        `
+  }
+};
+async function handleImport(groupConfig, request, context) {
+  for (const [_, config] of Object.entries(frameworksConfig)) {
+    if (request.startsWith(config.prefix)) {
+      const groupName = request.substring(config.prefix.length);
+      const relativeModulePath = `node_modules/${config.prefix}${groupName}.js`;
+      const absoluteModulePath = import_node_path.default.resolve(context, relativeModulePath);
+      if (!groupConfig[groupName]) {
+        throw new Error(`Font group ${groupName} not found`);
+      }
+      const curConfig = groupConfig[groupName];
+      const fontResult = await createFontStyle(curConfig);
+      const fontVarString = `{ fontClassName: "${fontResult.fontClassName}", fontBase64: "${fontResult.fontBase64}", fontText: "${curConfig.glyph}" }`;
+      const moduleContent = config.generateModule(fontVarString);
+      return {
+        moduleContent,
+        absoluteModulePath
+      };
+    }
+  }
+  return {
+    moduleContent: void 0,
+    absoluteModulePath: void 0
+  };
+}
+var unpluginFactory = (options) => {
+  const groups = options?.groups || {};
+  const virtualModules = /* @__PURE__ */ new Map();
+  return {
+    name: "fontmin-plugin",
+    enforce: "pre",
+    async resolveId(source, importer) {
+      const { moduleContent, absoluteModulePath } = await handleImport(
+        groups,
+        source,
+        importer ? process.cwd() : ""
+      );
+      if (absoluteModulePath) {
+        virtualModules.set(source, moduleContent || "");
+        return source;
+      }
+      return null;
+    },
+    load(id) {
+      if (virtualModules.has(id)) {
+        return virtualModules.get(id);
+      }
+      return null;
+    },
+    loadInclude(id) {
+      return id.startsWith(importerPrefix);
+    }
+  };
+};
+var unplugin = (0, import_unplugin.createUnplugin)(unpluginFactory);
+var index_default = unplugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  frameworksConfig,
+  handleImport,
+  unplugin,
+  unpluginFactory
+});

package/dist/index.d.cts

@@ -0,0 +1,35 @@
+import * as _unplugin from 'unplugin';
+import { UnpluginFactory } from 'unplugin';
+
+declare const presets: {
+    numbers: string;
+    lowerCase: string;
+    upperCase: string;
+    symbols: string;
+    allBasic: string;
+};
+interface FontConfig {
+    fontPath: string;
+    glyph?: string;
+    presets?: Array<keyof typeof presets>;
+}
+
+interface Options {
+    groups?: Record<string, FontConfig>;
+}
+interface FrameworkConfig {
+    prefix: string;
+    generateModule: (fontVarString: string) => string;
+}
+declare const frameworksConfig: Record<'react' | 'vue', FrameworkConfig>;
+declare function handleImport(groupConfig: Record<string, FontConfig>, request: string, context: string): Promise<{
+    moduleContent: string;
+    absoluteModulePath: string;
+} | {
+    moduleContent: undefined;
+    absoluteModulePath: undefined;
+}>;
+declare const unpluginFactory: UnpluginFactory<Options | undefined>;
+declare const unplugin: _unplugin.UnpluginInstance<Options | undefined, boolean>;
+
+export { type Options, unplugin as default, frameworksConfig, handleImport, unplugin, unpluginFactory };

package/dist/index.d.ts

@@ -1,20 +1,35 @@
-import type { FontConfig } from '@fontmin-plugin/core';
-import type { UnpluginFactory } from 'unplugin';
-export interface Options {
+import * as _unplugin from 'unplugin';
+import { UnpluginFactory } from 'unplugin';
+
+declare const presets: {
+    numbers: string;
+    lowerCase: string;
+    upperCase: string;
+    symbols: string;
+    allBasic: string;
+};
+interface FontConfig {
+    fontPath: string;
+    glyph?: string;
+    presets?: Array<keyof typeof presets>;
+}
+
+interface Options {
     groups?: Record<string, FontConfig>;
 }
 interface FrameworkConfig {
     prefix: string;
     generateModule: (fontVarString: string) => string;
 }
-export declare const frameworksConfig: Record<'react' | 'vue', FrameworkConfig>;
-export declare function handleImport(groupConfig: Record<string, FontConfig>, request: string, context: string): Promise<{
+declare const frameworksConfig: Record<'react' | 'vue', FrameworkConfig>;
+declare function handleImport(groupConfig: Record<string, FontConfig>, request: string, context: string): Promise<{
     moduleContent: string;
     absoluteModulePath: string;
 } | {
     moduleContent: undefined;
     absoluteModulePath: undefined;
 }>;
-export declare const unpluginFactory: UnpluginFactory<Options | undefined>;
-export declare const unplugin: import("unplugin").UnpluginInstance<Options | undefined, boolean>;
-export default unplugin;
+declare const unpluginFactory: UnpluginFactory<Options | undefined>;
+declare const unplugin: _unplugin.UnpluginInstance<Options | undefined, boolean>;
+
+export { type Options, unplugin as default, frameworksConfig, handleImport, unplugin, unpluginFactory };

package/dist/index.js

@@ -1,79 +1,136 @@
-import path from 'node:path';
-import { createFontStyle } from '@fontmin-plugin/core';
-import { createUnplugin } from 'unplugin';
-const importerPrefix = '@fontmin-plugin/';
-export const frameworksConfig = {
-    react: {
-        prefix: `${importerPrefix}react/`,
-        generateModule: (fontVarString) => `
+// src/index.tsx
+import path from "path";
+import { createUnplugin } from "unplugin";
+
+// src/core.ts
+import { promisify } from "util";
+import Fontmin from "fontmin";
+import { list } from "radash";
+var presets = {
+  numbers: "0123456789",
+  lowerCase: "abcdefghijklmnopqrstuvwxyz",
+  upperCase: "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+  symbols: "!@#$%^&*()_+-=[]{}|;:,.<>?`~",
+  allBasic: String.fromCharCode.apply(void 0, list(33, 126))
+};
+var classNameCounter = 0;
+var generateClassName = () => {
+  classNameCounter++;
+  return `fontmin_${classNameCounter}_${Date.now()}_${Math.random().toString(36).slice(2, 6)}`;
+};
+var loadAndProcessFont = async (config) => {
+  const text = `${config.presets?.map((preset) => presets[preset] || "").join("") || ""}${config.glyph || ""}`;
+  if (!text || !config.fontPath) {
+    console.error(
+      new Error("No text or font path to process, Please check your config")
+    );
+    return "";
+  }
+  const fontmin = new Fontmin().src(config.fontPath).use(Fontmin.glyph({ text, hinting: false }));
+  const runAsync = promisify(fontmin.run.bind(fontmin));
+  const files = await runAsync();
+  if (!files?.[0]) {
+    console.error(new Error("Font processing failed"));
+    return "";
+  }
+  const buffer = files[0].contents;
+  return buffer.toString("base64");
+};
+async function createFontStyle(config) {
+  try {
+    const className = generateClassName();
+    const base64 = await loadAndProcessFont(config);
+    return {
+      fontClassName: className,
+      fontBase64: base64
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to create font style: ${message}`);
+  }
+}
+
+// src/index.tsx
+var importerPrefix = "@fontmin-plugin/";
+var frameworksConfig = {
+  react: {
+    prefix: `${importerPrefix}react/`,
+    generateModule: (fontVarString) => `
           import { createElement } from 'react';
           import FontminText from '@fontmin-plugin/react';
           const fontConfig = ${fontVarString};
           export default (props) => createElement(FontminText, { ...fontConfig, ...props });
-        `,
-    },
-    vue: {
-        prefix: `${importerPrefix}vue/`,
-        generateModule: (fontVarString) => `
+        `
+  },
+  vue: {
+    prefix: `${importerPrefix}vue/`,
+    generateModule: (fontVarString) => `
           import { h } from 'vue';
           import FontminText from '@fontmin-plugin/vue';
           const fontConfig = ${fontVarString};
           export default h(FontminText, { ...fontConfig });
-        `,
-    },
+        `
+  }
 };
-export async function handleImport(groupConfig, request, context) {
-    // 遍历frameworks配置，检查请求是否匹配任何一个前缀
-    for (const [_, config] of Object.entries(frameworksConfig)) {
-        if (request.startsWith(config.prefix)) {
-            // 从请求路径提取组名
-            const groupName = request.substring(config.prefix.length);
-            // 为该路径创建一个虚拟模块文件
-            // Use absolute path for virtual module
-            const relativeModulePath = `node_modules/${config.prefix}${groupName}.js`;
-            const absoluteModulePath = path.resolve(context, relativeModulePath);
-            if (!groupConfig[groupName]) {
-                throw new Error(`Font group ${groupName} not found`);
-            }
-            const curConfig = groupConfig[groupName];
-            const fontResult = await createFontStyle(curConfig);
-            const fontVarString = `{ fontClassName: "${fontResult.fontClassName}", fontBase64: "${fontResult.fontBase64}", fontText: "${curConfig.glyph}" }`;
-            const moduleContent = config.generateModule(fontVarString);
-            return {
-                moduleContent,
-                absoluteModulePath,
-            };
-        }
+async function handleImport(groupConfig, request, context) {
+  for (const [_, config] of Object.entries(frameworksConfig)) {
+    if (request.startsWith(config.prefix)) {
+      const groupName = request.substring(config.prefix.length);
+      const relativeModulePath = `node_modules/${config.prefix}${groupName}.js`;
+      const absoluteModulePath = path.resolve(context, relativeModulePath);
+      if (!groupConfig[groupName]) {
+        throw new Error(`Font group ${groupName} not found`);
+      }
+      const curConfig = groupConfig[groupName];
+      const fontResult = await createFontStyle(curConfig);
+      const fontVarString = `{ fontClassName: "${fontResult.fontClassName}", fontBase64: "${fontResult.fontBase64}", fontText: "${curConfig.glyph}" }`;
+      const moduleContent = config.generateModule(fontVarString);
+      return {
+        moduleContent,
+        absoluteModulePath
+      };
     }
-    return {
-        moduleContent: undefined,
-        absoluteModulePath: undefined,
-    };
+  }
+  return {
+    moduleContent: void 0,
+    absoluteModulePath: void 0
+  };
 }
-export const unpluginFactory = (options) => {
-    const groups = options?.groups || {};
-    const virtualModules = new Map();
-    return {
-        name: 'fontmin-plugin',
-        enforce: 'pre',
-        async resolveId(source, importer) {
-            const { moduleContent, absoluteModulePath } = await handleImport(groups, source, importer ? process.cwd() : '');
-            if (absoluteModulePath) {
-                virtualModules.set(source, moduleContent || '');
-                return source;
-            }
-            return null;
-        },
-        load(id) {
-            if (virtualModules.has(id)) {
-                return virtualModules.get(id);
-            }
-            return null;
-        },
-        loadInclude(id) {
-            return id.startsWith(importerPrefix);
-        },
-    };
+var unpluginFactory = (options) => {
+  const groups = options?.groups || {};
+  const virtualModules = /* @__PURE__ */ new Map();
+  return {
+    name: "fontmin-plugin",
+    enforce: "pre",
+    async resolveId(source, importer) {
+      const { moduleContent, absoluteModulePath } = await handleImport(
+        groups,
+        source,
+        importer ? process.cwd() : ""
+      );
+      if (absoluteModulePath) {
+        virtualModules.set(source, moduleContent || "");
+        return source;
+      }
+      return null;
+    },
+    load(id) {
+      if (virtualModules.has(id)) {
+        return virtualModules.get(id);
+      }
+      return null;
+    },
+    loadInclude(id) {
+      return id.startsWith(importerPrefix);
+    }
+  };
+};
+var unplugin = createUnplugin(unpluginFactory);
+var index_default = unplugin;
+export {
+  index_default as default,
+  frameworksConfig,
+  handleImport,
+  unplugin,
+  unpluginFactory
 };
-export const unplugin = createUnplugin(unpluginFactory);
-export default unplugin;

package/package.json

@@ -1,25 +1,30 @@
 {
   "name": "@fontmin-plugin/plugin",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "type": "module",
+  "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": ["dist"],
   "exports": {
     ".": {
+      "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
-      "require": "./dist/index.js"
+      "require": "./dist/index.cjs"
     }
   },
   "scripts": {
-    "build": "tsc"
+    "build": "tsup src/index.tsx --format esm,cjs --dts --clean",
+    "publish": "bun run build && bun publish --access public"
   },
   "dependencies": {
-    "@fontmin-plugin/core": "workspace:*",
-    "unplugin": "^2.3.4"
+    "unplugin": "^2.3.4",
+    "fontmin": "^1.0.0",
+    "radash": "^7.0.0"
   },
   "devDependencies": {
-    "@types/bun": "latest"
+    "@types/bun": "latest",
+    "tsup": "^8.0.2"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"