@onexapis/cli 1.1.10 → 1.1.12

package/dist/cli.js

@@ -155,8 +155,37 @@ async function resolveNodeModulesFile(startDir, relativePath) {
   }
   return null;
 }
+async function scanImportsFromPackage(sourceDir, packageName) {
+  const result = {};
+  const escapedPkg = packageName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const importRegex = new RegExp(
+    `(?:import|export)\\s+(?:type\\s+)?\\{([^}]+)\\}\\s+from\\s+["']${escapedPkg}(/[\\w./-]+)?["']`,
+    "g"
+  );
+  const sourceFiles = await glob.glob("**/*.{ts,tsx}", {
+    cwd: sourceDir,
+    ignore: ["node_modules/**", "dist/**"]
+  });
+  for (const file of sourceFiles) {
+    try {
+      const content = await fs7__default.default.readFile(path8__default.default.join(sourceDir, file), "utf-8");
+      for (const match of content.matchAll(importRegex)) {
+        const subpath = match[2] ? match[2].slice(1) : "";
+        if (!result[subpath]) result[subpath] = /* @__PURE__ */ new Set();
+        for (const name of match[1].split(",")) {
+          let original = name.trim().split(/\s+as\s+/)[0].trim();
+          if (original.startsWith("type ")) continue;
+          if (original) result[subpath].add(original);
+        }
+      }
+    } catch {
+    }
+  }
+  return result;
+}
 function createCoreGlobalPlugin(themePath) {
   const exportsBySubpath = {};
+  let scanPromise = null;
   return {
     name: "core-global",
     setup(build2) {
@@ -165,6 +194,16 @@ function createCoreGlobalPlugin(themePath) {
         namespace: "core-global"
       }));
       build2.onLoad({ filter: /.*/, namespace: "core-global" }, async (args) => {
+        if (!scanPromise) {
+          scanPromise = scanImportsFromPackage(themePath, "@onexapis/core").then((scanned) => {
+            for (const [subpath2, names] of Object.entries(scanned)) {
+              const cacheKey2 = subpath2 || "__root__";
+              exportsBySubpath[cacheKey2] = [...names];
+            }
+          }).catch(() => {
+          });
+        }
+        await scanPromise;
         const match = args.path.match(/^@onexapis\/core(\/(.+))?$/);
         const subpath = match?.[2] || "";
         const moduleAccess = subpath ? `['${subpath}']` : "";
@@ -228,6 +267,160 @@ ${namedExportLines}
     }
   };
 }
+function createThemeDepsStubPlugin(themePath) {
+  return {
+    name: "theme-deps-stub",
+    setup(build2) {
+      const tryResolveOrStub = (filter, namespace) => {
+        build2.onResolve({ filter }, async (args) => {
+          if (args.pluginData?.skipStub) return void 0;
+          try {
+            const result = await build2.resolve(args.path, {
+              kind: args.kind,
+              resolveDir: args.resolveDir || themePath,
+              importer: args.importer,
+              namespace: "file",
+              pluginData: { skipStub: true }
+            });
+            if (!result.errors.length) return result;
+          } catch {
+          }
+          return { path: args.path, namespace };
+        });
+      };
+      tryResolveOrStub(/^next\//, "next-stub");
+      build2.onLoad({ filter: /.*/, namespace: "next-stub" }, (args) => {
+        const stubs = {
+          "next/image": `
+import React from 'react';
+const Image = (props) => {
+  const { src, alt, width, height, fill, priority, ...rest } = props;
+  const imgSrc = typeof src === 'object' ? src.src : src;
+  return React.createElement('img', { src: imgSrc, alt, width: fill ? undefined : width, height: fill ? undefined : height, loading: priority ? 'eager' : 'lazy', ...rest });
+};
+export default Image;
+          `,
+          "next/link": `
+import React from 'react';
+const Link = ({ href, children, ...rest }) => React.createElement('a', { href, ...rest }, children);
+export default Link;
+          `,
+          "next/navigation": `
+export function useRouter() { return { push(u){window.location.href=u}, replace(u){window.location.href=u}, back(){window.history.back()}, forward(){window.history.forward()}, refresh(){window.location.reload()}, prefetch(){} }; }
+export function usePathname() { return window.location.pathname; }
+export function useSearchParams() { return new URLSearchParams(window.location.search); }
+export function useParams() { return {}; }
+export function redirect(url) { window.location.href = url; }
+export function notFound() { throw new Error('Not Found'); }
+          `,
+          "next/headers": `
+export function cookies() { return { get(){}, getAll(){ return []; }, set(){}, delete(){}, has(){ return false; } }; }
+export function headers() { return new Headers(); }
+          `
+        };
+        return {
+          contents: stubs[args.path] || "export default {};",
+          loader: "jsx",
+          resolveDir: themePath
+        };
+      });
+      const lucideImports = /* @__PURE__ */ new Set();
+      let lucideThemeScanned = false;
+      tryResolveOrStub(/^lucide-react/, "lucide-stub");
+      build2.onLoad({ filter: /.*/, namespace: "lucide-stub" }, async () => {
+        if (!lucideThemeScanned) {
+          lucideThemeScanned = true;
+          try {
+            const scanned = await scanImportsFromPackage(themePath, "lucide-react");
+            for (const names of Object.values(scanned)) {
+              for (const name of names) lucideImports.add(name);
+            }
+          } catch {
+          }
+        }
+        const iconNames = [...lucideImports];
+        const exports$1 = iconNames.map((n) => `icon as ${n}`).join(", ");
+        return {
+          contents: `
+const icon = (props) => null;
+export { ${exports$1} };
+export default new Proxy({}, { get: (_, name) => name === '__esModule' ? true : icon });
+          `.trim(),
+          loader: "jsx"
+        };
+      });
+      tryResolveOrStub(/^framer-motion/, "motion-stub");
+      build2.onLoad({ filter: /.*/, namespace: "motion-stub" }, () => ({
+        contents: `
+import React from 'react';
+const handler = { get: (_, name) => {
+  if (name === '__esModule') return true;
+  return React.forwardRef((props, ref) => React.createElement(name, { ...props, ref }));
+}};
+export const motion = new Proxy({}, handler);
+export const AnimatePresence = ({ children }) => children || null;
+export function useInView() { return true; }
+export default { motion, AnimatePresence, useInView };
+        `.trim(),
+        loader: "jsx",
+        resolveDir: themePath
+      }));
+      tryResolveOrStub(/^sonner$/, "sonner-stub");
+      build2.onLoad({ filter: /.*/, namespace: "sonner-stub" }, () => ({
+        contents: `
+export const toast = new Proxy(() => {}, { get: () => () => {} });
+export const Toaster = () => null;
+export default { toast, Toaster };
+        `.trim(),
+        loader: "jsx"
+      }));
+      tryResolveOrStub(/^react-hook-form$/, "rhf-stub");
+      build2.onLoad({ filter: /.*/, namespace: "rhf-stub" }, () => ({
+        contents: `
+export function useForm() {
+  return {
+    register: () => ({}),
+    handleSubmit: (fn) => (e) => { e?.preventDefault?.(); fn({}); },
+    formState: { errors: {}, isSubmitting: false, isValid: true },
+    watch: () => undefined,
+    setValue: () => {},
+    reset: () => {},
+    control: {},
+  };
+}
+export function useController() { return { field: {}, fieldState: {} }; }
+export function useFormContext() { return useForm(); }
+        `.trim(),
+        loader: "js"
+      }));
+      tryResolveOrStub(/^@hookform\/resolvers/, "hookform-resolvers-stub");
+      build2.onLoad({ filter: /.*/, namespace: "hookform-resolvers-stub" }, () => ({
+        contents: `export function zodResolver() { return () => ({ values: {}, errors: {} }); }`,
+        loader: "js"
+      }));
+      tryResolveOrStub(/^next-intl$/, "next-intl-stub");
+      build2.onLoad({ filter: /.*/, namespace: "next-intl-stub" }, () => ({
+        contents: `
+export function useTranslations(ns) {
+  return (key) => ns ? ns + '.' + key : key;
+}
+export function useLocale() { return 'en'; }
+export function useMessages() { return {}; }
+        `.trim(),
+        loader: "js"
+      }));
+      tryResolveOrStub(/^zod$/, "zod-stub");
+      build2.onLoad({ filter: /.*/, namespace: "zod-stub" }, () => ({
+        contents: `
+const schema = () => ({ parse: (v) => v, safeParse: (v) => ({ success: true, data: v }), optional: schema, min: schema, max: schema, email: schema, url: schema, regex: schema, refine: schema, transform: schema });
+export const z = { string: schema, number: schema, boolean: schema, object: (s) => ({ ...schema(), shape: s }), array: schema, enum: schema, union: schema, literal: schema, infer: undefined };
+export default z;
+        `.trim(),
+        loader: "js"
+      }));
+    }
+  };
+}
 async function generateThemeData(themePath, outputDir, themeId) {
   const { createJiti } = await import('jiti');
   const jiti = createJiti((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('cli.js', document.baseURI).href)));
@@ -462,7 +655,7 @@ async function compileStandaloneTheme(themePath, themeName) {
     banner: {
       js: '"use client";'
     },
-    plugins: [reactGlobalPlugin, createCoreGlobalPlugin(themePath)],
+    plugins: [reactGlobalPlugin, createCoreGlobalPlugin(themePath), createThemeDepsStubPlugin(themePath)],
     external: [],
     alias: {
       events: "events/",
@@ -544,7 +737,7 @@ async function compileStandaloneThemeDev(themePath, themeName) {
     banner: {
       js: '"use client";'
     },
-    plugins: [reactGlobalPlugin, createCoreGlobalPlugin(themePath)],
+    plugins: [reactGlobalPlugin, createCoreGlobalPlugin(themePath), createThemeDepsStubPlugin(themePath)],
     external: [],
     alias: {
       events: "events/",
@@ -655,6 +848,8 @@ ${locations.join("\n")}`
           loader: "js"
         };
       });
+      const lucideIconNames = /* @__PURE__ */ new Set();
+      let lucideScanned = false;
       build2.onResolve({ filter: /^lucide-react/ }, async (args) => {
         if (args.pluginData?.skipStub) return void 0;
         try {
@@ -670,23 +865,93 @@ ${locations.join("\n")}`
         }
         return { path: args.path, namespace: "lucide-stub" };
       });
-      build2.onLoad({ filter: /.*/, namespace: "lucide-stub" }, () => ({
-        // Provide all icon names used by @onexapis/core as no-op SVG stub components
-        contents: `
+      build2.onLoad({ filter: /.*/, namespace: "lucide-stub" }, async () => {
+        if (!lucideScanned) {
+          lucideScanned = true;
+          const coreSrcCandidates = [
+            path8__default.default.join(themePath, "node_modules", "@onexapis", "core", "src"),
+            path8__default.default.join(themePath, "..", "..", "packages", "core", "src"),
+            // monorepo sibling
+            path8__default.default.join(__dirname, "..", "..", "..", "..", "packages", "core", "src")
+            // from CLI src
+          ];
+          let coreSourceDir = null;
+          for (const candidate of coreSrcCandidates) {
+            try {
+              await fs7__default.default.access(candidate);
+              coreSourceDir = candidate;
+              break;
+            } catch {
+            }
+          }
+          if (coreSourceDir) {
+            try {
+              const scanned = await scanImportsFromPackage(coreSourceDir, "lucide-react");
+              for (const names of Object.values(scanned)) {
+                for (const name of names) lucideIconNames.add(name);
+              }
+            } catch {
+            }
+          }
+          try {
+            const scanned = await scanImportsFromPackage(themePath, "lucide-react");
+            for (const names of Object.values(scanned)) {
+              for (const name of names) lucideIconNames.add(name);
+            }
+          } catch {
+          }
+        }
+        if (lucideIconNames.size === 0) {
+          const fallbackIcons = [
+            "Check",
+            "ChevronDown",
+            "XCircle",
+            "AlertTriangle",
+            "CheckCircle",
+            "Info",
+            "X",
+            "XIcon",
+            "CircleIcon",
+            "Star",
+            "ShoppingCart",
+            "ChevronRight",
+            "ChevronLeft",
+            "ChevronUp",
+            "Search",
+            "Menu",
+            "Heart",
+            "User",
+            "Trash2",
+            "Plus",
+            "Minus",
+            "Eye",
+            "EyeOff",
+            "ArrowRight",
+            "ArrowLeft",
+            "ExternalLink",
+            "Mail",
+            "Phone",
+            "MapPin",
+            "Calendar",
+            "Clock",
+            "Facebook",
+            "Twitter",
+            "Instagram",
+            "Linkedin",
+            "Github"
+          ];
+          for (const icon of fallbackIcons) lucideIconNames.add(icon);
+        }
+        const iconExports = [...lucideIconNames].map((n) => `icon as ${n}`).join(", ");
+        return {
+          contents: `
 const icon = (props) => null;
-export { icon as Check, icon as ChevronDown, icon as XCircle, icon as AlertTriangle };
-export { icon as CheckCircle, icon as Info, icon as X, icon as XIcon };
-export { icon as CircleIcon, icon as Star, icon as ShoppingCart };
-export { icon as ChevronRight, icon as ChevronLeft, icon as ChevronUp };
-export { icon as Search, icon as Menu, icon as Heart, icon as User };
-export { icon as Trash2, icon as Plus, icon as Minus, icon as Eye, icon as EyeOff };
-export { icon as ArrowRight, icon as ArrowLeft, icon as ExternalLink, icon as Mail };
-export { icon as Phone, icon as MapPin, icon as Calendar, icon as Clock };
-export { icon as Facebook, icon as Twitter, icon as Instagram, icon as Linkedin, icon as Github };
+export { ${iconExports} };
 export default new Proxy({}, { get: (_, name) => name === '__esModule' ? true : icon });
-        `.trim(),
-        loader: "jsx"
-      }));
+          `.trim(),
+          loader: "jsx"
+        };
+      });
       build2.onResolve({ filter: /^framer-motion/ }, async (args) => {
         if (args.pluginData?.skipStub) return void 0;
         try {