@sky.ui/core 0.0.28 → 0.0.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sky.ui/core",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "Sky UI web components built with Lit — 70+ components, bundler plugins, and custom elements.",
   "keywords": [
     "sky-ui",
@@ -29,6 +29,10 @@
     "plugins/webpack-plugin.d.ts",
     "plugins/rollup-plugin.js",
     "plugins/rollup-plugin.d.ts",
+    "plugins/ce-auto-import.js",
+    "plugins/ce-auto-import.d.ts",
+    "plugins/stack-resolvers.js",
+    "plugins/stack-resolvers.d.ts",
     "README.md",
     "LICENSE.md",
     "CHANGELOG.md"
@@ -41,6 +45,16 @@
     },
     "./auto-import": "./auto-import.js",
     "./auto-import-loader": "./auto-import-loader.js",
+    "./ce-auto-import": {
+      "types": "./plugins/ce-auto-import.d.ts",
+      "import": "./plugins/ce-auto-import.js",
+      "default": "./plugins/ce-auto-import.js"
+    },
+    "./stack-resolvers": {
+      "types": "./plugins/stack-resolvers.d.ts",
+      "import": "./plugins/stack-resolvers.js",
+      "default": "./plugins/stack-resolvers.js"
+    },
     "./custom-elements.json": "./dist/custom-elements.json",
     "./all": {
       "import": "./dist/index.js",

package/plugins/ce-auto-import.d.ts

@@ -0,0 +1,18 @@
+import type { Plugin } from "vite";
+export type SkyCeAutoImportTier = "free" | "pro" | "ultra";
+export interface SkyCeAutoImportOptions {
+    /** Highest paid tier available — includes lower-tier tags. Default: free */
+    tier?: SkyCeAutoImportTier;
+    /** Project root used for node_modules lookups. Default: process.cwd() */
+    root?: string;
+    /** Extra path substrings to skip. */
+    exclude?: string[];
+}
+/** @deprecated Prefer SkyCeAutoImportOptions */
+export type SkyVueCeAutoImportOptions = SkyCeAutoImportOptions;
+/**
+ * Vite plugin: scan modules for <sky-*> and inject `@sky.ui(.pro|.ultra)/core/<tag>` imports.
+ */
+export declare function createSkyCeAutoImportPlugin(options?: SkyCeAutoImportOptions): Plugin;
+/** @deprecated Prefer createSkyCeAutoImportPlugin */
+export declare const createSkyVueCeAutoImportPlugin: typeof createSkyCeAutoImportPlugin;

package/plugins/ce-auto-import.js

@@ -0,0 +1,160 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// plugins/ce-auto-import.ts
+import { existsSync } from "fs";
+import { createRequire } from "module";
+import { join } from "path";
+var require2 = createRequire(import.meta.url);
+var VIRTUAL_ID = "\0sky-ui-ce-auto-import";
+var VIRTUAL_QUERY = "virtual:sky-ui-ce-auto-import";
+var TAG_RE = /<(sky-[a-z][a-z0-9]*(?:-[a-z0-9]+)*)/gi;
+var TRANSFORM_EXT_RE = /\.(vue|tsx|jsx|ts|js|mjs|html)$/i;
+function pascalToKebabSky(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/^Sky-?/, "sky-").toLowerCase();
+}
+__name(pascalToKebabSky, "pascalToKebabSky");
+function tryLoadTagSet(specifier) {
+  try {
+    const mod = require2(specifier);
+    if (mod.SKY_UI_TAG_NAMES instanceof Set) return new Set(mod.SKY_UI_TAG_NAMES);
+    if (Array.isArray(mod.SKY_UI_COMPONENTS)) {
+      return new Set(mod.SKY_UI_COMPONENTS.map(pascalToKebabSky));
+    }
+  } catch {
+  }
+  return /* @__PURE__ */ new Set();
+}
+__name(tryLoadTagSet, "tryLoadTagSet");
+function loadTierSets(tier) {
+  const free = tryLoadTagSet("@sky.ui/core/auto-import");
+  const pro = tier === "pro" || tier === "ultra" ? tryLoadTagSet("@sky.ui.pro/core/auto-import") : /* @__PURE__ */ new Set();
+  const ultra = tier === "ultra" ? tryLoadTagSet("@sky.ui.ultra/core/auto-import") : /* @__PURE__ */ new Set();
+  return {
+    free,
+    pro,
+    ultra
+  };
+}
+__name(loadTierSets, "loadTierSets");
+function coreImportPath(tag, sets) {
+  if (sets.ultra.has(tag)) return `@sky.ui.ultra/core/${tag}`;
+  if (sets.pro.has(tag)) return `@sky.ui.pro/core/${tag}`;
+  if (sets.free.has(tag)) return `@sky.ui/core/${tag}`;
+  return null;
+}
+__name(coreImportPath, "coreImportPath");
+function coreModuleExists(pkg, root) {
+  const match = pkg.match(/^(@sky\.ui(?:\.pro|\.ultra)?\/core)\/(.+)$/);
+  if (!match) return false;
+  const packageRoot = join(root, "node_modules", ...match[1].split("/"));
+  const distDir = join(packageRoot, "dist", match[2]);
+  return existsSync(join(distDir, "index.js")) || existsSync(join(distDir, `${match[2]}.js`));
+}
+__name(coreModuleExists, "coreModuleExists");
+function extractTags(content) {
+  const tags = /* @__PURE__ */ new Set();
+  let match;
+  TAG_RE.lastIndex = 0;
+  while ((match = TAG_RE.exec(content)) !== null) {
+    tags.add(match[1].toLowerCase());
+  }
+  return tags;
+}
+__name(extractTags, "extractTags");
+function shouldTransform(id, exclude) {
+  if (!id || id.startsWith("\0") || id.includes("\0")) return false;
+  const clean = id.split("?")[0].replace(/\\/g, "/");
+  if (clean.includes("/node_modules/")) return false;
+  if (!TRANSFORM_EXT_RE.test(clean)) return false;
+  for (const part of exclude) {
+    if (clean.includes(part.replace(/\\/g, "/"))) return false;
+  }
+  return true;
+}
+__name(shouldTransform, "shouldTransform");
+function injectImportLines(code, importLines, fileId) {
+  if (!importLines.length) return null;
+  const block = `${importLines.join("\n")}
+`;
+  const clean = fileId.split("?")[0].replace(/\\/g, "/");
+  if (clean.endsWith(".vue")) {
+    const setupOpen = code.match(/<script\b[^>]*\bsetup\b[^>]*>/i);
+    if (setupOpen && setupOpen.index != null) {
+      const idx = setupOpen.index + setupOpen[0].length;
+      return {
+        code: code.slice(0, idx) + "\n" + block + code.slice(idx),
+        map: null
+      };
+    }
+    const scriptOpen = code.match(/<script\b[^>]*>/i);
+    if (scriptOpen && scriptOpen.index != null) {
+      const idx = scriptOpen.index + scriptOpen[0].length;
+      return {
+        code: code.slice(0, idx) + "\n" + block + code.slice(idx),
+        map: null
+      };
+    }
+    return {
+      code: `${code}
+<script setup>
+${block}</script>
+`,
+      map: null
+    };
+  }
+  return {
+    code: block + code,
+    map: null
+  };
+}
+__name(injectImportLines, "injectImportLines");
+function createSkyCeAutoImportPlugin(options = {}) {
+  const tier = options.tier ?? "free";
+  const root = options.root ?? process.cwd();
+  const exclude = [
+    "/scripts/sky-vue-ce-auto-import",
+    "/plugins/ce-auto-import",
+    "/frameworks/",
+    ...options.exclude ?? []
+  ];
+  let sets = loadTierSets(tier);
+  return {
+    name: "sky-ui-ce-auto-import",
+    enforce: "pre",
+    buildStart() {
+      sets = loadTierSets(tier);
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_QUERY || id === VIRTUAL_ID) return VIRTUAL_ID;
+      return null;
+    },
+    load(id) {
+      if (id !== VIRTUAL_ID) return null;
+      return "/** Per-file sky-* CE imports \u2014 virtual entry is intentionally empty. */\n";
+    },
+    transform(code, id) {
+      if (typeof code !== "string" || !shouldTransform(id, exclude)) return null;
+      const tags = extractTags(code);
+      if (!tags.size) return null;
+      const pkgs = [
+        ...tags
+      ].sort().map((tag) => coreImportPath(tag, sets)).filter((pkg) => Boolean(pkg) && coreModuleExists(pkg, root));
+      const toInject = pkgs.filter((pkg) => {
+        if (code.includes(`'${pkg}'`) || code.includes(`"${pkg}"`) || code.includes(`\`${pkg}\``)) {
+          return false;
+        }
+        const escaped = pkg.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+        return !new RegExp(`import\\(\\s*['"\`]${escaped}['"\`]\\s*\\)`).test(code);
+      });
+      if (!toInject.length) return null;
+      return injectImportLines(code, toInject.map((pkg) => `import '${pkg}';`), id);
+    }
+  };
+}
+__name(createSkyCeAutoImportPlugin, "createSkyCeAutoImportPlugin");
+var createSkyVueCeAutoImportPlugin = createSkyCeAutoImportPlugin;
+export {
+  createSkyCeAutoImportPlugin,
+  createSkyVueCeAutoImportPlugin
+};

package/plugins/stack-resolvers.d.ts

@@ -0,0 +1,10 @@
+export type SkyMainResolverFn = (componentName: string) => {
+    name: string;
+    from: string;
+} | undefined;
+/** Free-only Main resolvers. */
+export declare function skyUiFreeMainResolvers(options?: Record<string, unknown>): SkyMainResolverFn[];
+/** Pro includes free. */
+export declare function skyUiProMainResolvers(options?: Record<string, unknown>): SkyMainResolverFn[];
+/** Ultra includes free + pro. */
+export declare function skyUiUltraMainResolvers(options?: Record<string, unknown>): SkyMainResolverFn[];

package/plugins/stack-resolvers.js

@@ -0,0 +1,43 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// plugins/stack-resolvers.ts
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+function tryResolver(specifier, exportName, options) {
+  try {
+    const mod = require2(specifier);
+    const factory = mod[exportName];
+    if (typeof factory !== "function") return null;
+    return factory(options);
+  } catch {
+    return null;
+  }
+}
+__name(tryResolver, "tryResolver");
+function skyUiFreeMainResolvers(options = {}) {
+  const free = tryResolver("@sky.ui/core/auto-import", "SkyUIMainResolver", options);
+  return free ? [
+    free
+  ] : [];
+}
+__name(skyUiFreeMainResolvers, "skyUiFreeMainResolvers");
+function skyUiProMainResolvers(options = {}) {
+  const list = skyUiFreeMainResolvers(options);
+  const pro = tryResolver("@sky.ui.pro/core/auto-import", "SkyUIProMainResolver", options);
+  if (pro) list.push(pro);
+  return list;
+}
+__name(skyUiProMainResolvers, "skyUiProMainResolvers");
+function skyUiUltraMainResolvers(options = {}) {
+  const list = skyUiProMainResolvers(options);
+  const ultra = tryResolver("@sky.ui.ultra/core/auto-import", "SkyUIUltraMainResolver", options);
+  if (ultra) list.push(ultra);
+  return list;
+}
+__name(skyUiUltraMainResolvers, "skyUiUltraMainResolvers");
+export {
+  skyUiFreeMainResolvers,
+  skyUiProMainResolvers,
+  skyUiUltraMainResolvers
+};

package/plugins/vite-plugin.d.ts

@@ -15,5 +15,10 @@ export interface SkyUIMainVitePluginOptions extends SkyUIMainAutoImportPluginOpt
     resolverOptions?: Record<string, unknown>;
     dts?: boolean;
     componentsOptions?: Record<string, unknown>;
+    /** Per-file <sky-*> CE imports. Default: true. */
+    ceAutoImport?: boolean;
+    root?: string;
 }
-export declare function SkyUIMainVitePlugin(options?: SkyUIMainVitePluginOptions): Plugin | Plugin[];
+export declare function SkyUIMainVitePlugin(options?: SkyUIMainVitePluginOptions): Plugin[];
+export { createSkyCeAutoImportPlugin, createSkyVueCeAutoImportPlugin } from "./ce-auto-import.js";
+export { skyUiFreeMainResolvers, skyUiProMainResolvers, skyUiUltraMainResolvers, } from "./stack-resolvers.js";

package/plugins/vite-plugin.js

@@ -7,6 +7,10 @@ import path from "path";
 import { fileURLToPath } from "url";
 import Components from "unplugin-vue-components/vite";
 import { SKY_UI_TAG_NAMES, getCoreImportPath, SkyUIMainResolver } from "../auto-import.js";
+import { createSkyCeAutoImportPlugin } from "./ce-auto-import.js";
+import { skyUiFreeMainResolvers } from "./stack-resolvers.js";
+import { createSkyCeAutoImportPlugin as createSkyCeAutoImportPlugin2, createSkyVueCeAutoImportPlugin } from "./ce-auto-import.js";
+import { skyUiFreeMainResolvers as skyUiFreeMainResolvers2, skyUiProMainResolvers, skyUiUltraMainResolvers } from "./stack-resolvers.js";
 var __dirname = path.dirname(fileURLToPath(import.meta.url));
 var CORE_DIST = path.resolve(__dirname, "..", "dist");
 var VIRTUAL_ID = "\0sky-ui-core-auto-import";
@@ -94,23 +98,40 @@ ${code}`,
 }
 __name(coreAutoImportVitePlugin, "coreAutoImportVitePlugin");
 function coreVueComponentsVitePlugin(options = {}) {
+  const resolverOptions = options.resolverOptions ?? {};
+  const resolvers = skyUiFreeMainResolvers(resolverOptions);
+  if (!resolvers.length) {
+    resolvers.push(SkyUIMainResolver(resolverOptions));
+  }
   return Components({
-    resolvers: [
-      SkyUIMainResolver(options.resolverOptions ?? {})
-    ],
+    resolvers,
     dts: options.dts !== false,
     ...options.componentsOptions
   });
 }
 __name(coreVueComponentsVitePlugin, "coreVueComponentsVitePlugin");
 function SkyUIMainVitePlugin(options = {}) {
-  const { mode = "vue", ...rest } = options;
+  const { mode = "vue", ceAutoImport = true, root, ...rest } = options;
+  const plugins = [];
+  if (ceAutoImport !== false) {
+    plugins.push(createSkyCeAutoImportPlugin({
+      tier: "free",
+      root
+    }));
+  }
   if (mode === "auto-import") {
-    return coreAutoImportVitePlugin(rest);
+    plugins.push(coreAutoImportVitePlugin(rest));
+    return plugins;
   }
-  return coreVueComponentsVitePlugin(rest);
+  plugins.push(coreVueComponentsVitePlugin(rest));
+  return plugins;
 }
 __name(SkyUIMainVitePlugin, "SkyUIMainVitePlugin");
 export {
-  SkyUIMainVitePlugin
+  SkyUIMainVitePlugin,
+  createSkyCeAutoImportPlugin2 as createSkyCeAutoImportPlugin,
+  createSkyVueCeAutoImportPlugin,
+  skyUiFreeMainResolvers2 as skyUiFreeMainResolvers,
+  skyUiProMainResolvers,
+  skyUiUltraMainResolvers
 };