silgi 0.24.18 → 0.24.19

package/dist/kit/index.mjs

@@ -1,13 +1,12 @@
-import consola$1, { consola } from 'consola';
-import { tryUseSilgiCLI, useSilgiCLI, useSilgi } from 'silgi';
+import { consola } from 'consola';
+import { tryUseSilgi, useSilgi, useSilgiApp } from 'silgi';
 import fsp from 'node:fs/promises';
-import { relative, resolve, dirname, normalize, isAbsolute, join, parse, basename } from 'pathe';
-import { colors } from 'consola/utils';
-import { getProperty } from 'dot-prop';
+import { dirname, resolve, normalize, isAbsolute, join, relative, parse, basename } from 'pathe';
+import { p as prettyPath, c as checkSilgiCompatibility } from '../_chunks/path.mjs';
+export { r as resolveSilgiPath } from '../_chunks/path.mjs';
 import { hash as hash$1 } from 'ohash';
 import { camelCase } from 'scule';
 import { defu } from 'defu';
-import { c as checkSilgiCompatibility } from '../cli/compatibility.mjs';
 import { withLeadingSlash } from 'ufo';
 import { existsSync, promises } from 'node:fs';
 import { fileURLToPath, pathToFileURL } from 'node:url';
@@ -17,49 +16,23 @@ import { hash as hash$2 } from 'silgi/kit';
 import { genString, genObjectFromRaw, genObjectFromValues, genObjectFromRawEntries } from 'knitwork';
 import 'semver/functions/satisfies.js';
 import 'silgi/meta';
+import 'consola/utils';
+import 'dot-prop';
 
 function useLogger(tag, options = {}) {
   return tag ? consola.create(options).withTag(tag) : consola;
 }
 
 function hasError(type, silgi) {
-  silgi = silgi ?? tryUseSilgiCLI() ?? void 0;
+  silgi = silgi ?? tryUseSilgi() ?? void 0;
   if (silgi && silgi.errors.some((error) => error.type === type)) {
     return true;
   }
   return false;
 }
 
-function prettyPath(p, highlight = true) {
-  p = relative(process.cwd(), p);
-  return highlight ? colors.cyan(p) : p;
-}
-function resolveSilgiPath(path, silgiCLIOptions, base) {
-  if (typeof path !== "string") {
-    throw new TypeError(`Invalid path: ${path}`);
-  }
-  path = _compilePathTemplate(path)(silgiCLIOptions);
-  for (const base2 in silgiCLIOptions.alias) {
-    if (path.startsWith(base2)) {
-      path = silgiCLIOptions.alias[base2] + path.slice(base2.length);
-    }
-  }
-  return resolve(base || silgiCLIOptions.srcDir, path);
-}
-function _compilePathTemplate(contents) {
-  return (params) => contents.replace(/\{\{ ?([\w.]+) ?\}\}/g, (_, match) => {
-    const val = getProperty(params, match);
-    if (!val) {
-      consola$1.warn(
-        `cannot resolve template param '${match}' in ${contents.slice(0, 20)}`
-      );
-    }
-    return val || `${match}`;
-  });
-}
-
 async function writeFile(file, contents, log = false) {
-  const silgi = useSilgiCLI();
+  const silgi = useSilgi();
   if (silgi.errors.length) {
     return;
   }
@@ -99,14 +72,14 @@ function _defineSilgiModule(definition) {
   }
   const module = defu(definition, { meta: {} });
   module.meta.configKey ||= module.meta.name;
-  async function getOptions(inlineOptions, silgi = useSilgiCLI()) {
+  async function getOptions(inlineOptions, silgi = useSilgi()) {
     const nuxtConfigOptionsKey = module.meta.configKey || module.meta.name;
     const nuxtConfigOptions = nuxtConfigOptionsKey && nuxtConfigOptionsKey in silgi.options ? silgi.options[nuxtConfigOptionsKey] : {};
     const optionsDefaults = typeof module.defaults === "function" ? await module.defaults(silgi) : module.defaults ?? {};
     const options = defu(inlineOptions, nuxtConfigOptions, optionsDefaults);
     return Promise.resolve(options);
   }
-  async function silgiNormalizedModule(inlineOptions, silgi = tryUseSilgiCLI()) {
+  async function silgiNormalizedModule(inlineOptions, silgi = tryUseSilgi()) {
     if (!silgi) {
       throw new TypeError("Cannot use module outside of Silgi context");
     }
@@ -253,7 +226,7 @@ async function isDirectory(path) {
   return (await promises.lstat(path)).isDirectory();
 }
 function resolveAlias(path, alias) {
-  alias ||= tryUseSilgiCLI()?.options.alias || {};
+  alias ||= tryUseSilgi()?.options.alias || {};
   return resolveAlias$1(path, alias || {});
 }
 function createResolver(base) {
@@ -299,10 +272,10 @@ function filterInPlace(array, predicate) {
   return array;
 }
 const MODE_RE = /\.(server|client)(\.\w+)*$/;
-function hasSilgiModule(moduleKey, silgi = useSilgiCLI()) {
+function hasSilgiModule(moduleKey, silgi = useSilgi()) {
   return silgi.scanModules.some(({ meta }) => meta.configKey === moduleKey) || Object.keys(silgi.scanModules).includes(moduleKey);
 }
-function hasInstalledModule(moduleKey, silgi = useSilgiCLI()) {
+function hasInstalledModule(moduleKey, silgi = useSilgi()) {
   const find = silgi.scanModules.find(({ meta }) => meta.configKey === moduleKey);
   return find?.installed ?? false;
 }
@@ -314,7 +287,7 @@ const baseHeaderBannerComment = [
   "/* tslint:disable */"
 ];
 function processFilePath(src) {
-  const silgi = useSilgiCLI();
+  const silgi = useSilgi();
   if (silgi.options.typescript.removeFileExtension) {
     src = src.replace(/\.ts$/, "");
     return src;
@@ -323,7 +296,7 @@ function processFilePath(src) {
 }
 
 function addTemplate(_template) {
-  const silgi = useSilgiCLI();
+  const silgi = useSilgi();
   const template = normalizeTemplate(_template);
   filterInPlace(silgi.options.build.templates, (p) => normalizeTemplate(p).dst !== template.dst);
   silgi.options.build.templates.push(template);
@@ -357,7 +330,7 @@ function normalizeTemplate(template, buildDir) {
     template.write = true;
   }
   if (!template.dst) {
-    const silgi = useSilgiCLI();
+    const silgi = useSilgi();
     const dir = template.where === ".silgi" ? silgi.options.build.dir : template.where === "server" ? silgi.options.silgi.serverDir : template.where === "client" ? silgi.options.silgi.clientDir : silgi.options.silgi.serverDir;
     template.dst = resolve(buildDir ?? dir, template.filename);
   }
@@ -365,21 +338,21 @@ function normalizeTemplate(template, buildDir) {
 }
 
 function useRequest(event) {
-  const silgi = useSilgi();
+  const silgi = useSilgiApp();
   if (silgi.options.present === "nuxt" || silgi.options.present === "nitro" || silgi.options.present === "h3") {
     return event.node.req;
   }
   return event;
 }
 function useResponse(event) {
-  const silgi = useSilgi();
+  const silgi = useSilgiApp();
   if (silgi.options.present === "nuxt" || silgi.options.present === "nitro" || silgi.options.present === "h3") {
     return event.node.res;
   }
   return event;
 }
 function getIpAddress(event) {
-  const silgi = useSilgi();
+  const silgi = useSilgiApp();
   if (silgi.options.present === "nuxt" || silgi.options.present === "nitro" || silgi.options.present === "h3") {
     const _ipAddress = ipAddress(event.node.req);
     return _ipAddress;
@@ -504,25 +477,25 @@ function getAllEntries(obj) {
 }
 
 function isNuxt() {
-  const silgi = useSilgi();
+  const silgi = useSilgiApp();
   if (silgi.options.present === "nitro" || silgi.options.present === "h3" || silgi.options.present === "nuxt") {
     return true;
   }
   return false;
 }
 function isNitro() {
-  const silgi = useSilgi();
+  const silgi = useSilgiApp();
   if (silgi.options.present === "nitro" || silgi.options.present === "h3") {
     return true;
   }
   return false;
 }
 function isH3() {
-  const silgi = useSilgi();
+  const silgi = useSilgiApp();
   if (silgi.options.present === "h3") {
     return true;
   }
   return false;
 }
 
-export { MODE_RE, addTemplate, baseHeaderBannerComment, createResolver, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, genEnsureSafeVar, getAllEntries, getIpAddress, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory$1 as isDirectory, isH3, isNitro, isNuxt, normalizeTemplate, parseServices, prettyPath, processFilePath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, resolveSilgiPath, serviceParseModule, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };
+export { MODE_RE, addTemplate, baseHeaderBannerComment, createResolver, defineSilgiModule, defineSilgiPreset, directoryToURL, filterInPlace, genEnsureSafeVar, getAllEntries, getIpAddress, hasError, hasInstalledModule, hasSilgiModule, hash, ipAddress, isDirectory$1 as isDirectory, isH3, isNitro, isNuxt, normalizeTemplate, parseServices, prettyPath, processFilePath, relativeWithDot, resolveAlias, resolvePath, resolveSilgiModule, serviceParseModule, toArray, tryResolveModule, useLogger, useRequest, useResponse, writeFile };

package/dist/runtime/internal/config.mjs

@@ -2,7 +2,7 @@ import defu from "defu";
 import destr from "destr";
 import { klona } from "klona";
 import { snakeCase } from "scule";
-import { tryUseSilgi, useSilgi } from "silgi";
+import { tryUseSilgiApp, useSilgiApp } from "silgi";
 let silgiRuntimeConfig = globalThis.__nitro__?.useRuntimeConfig?.() || process.env.RUNTIME_CONFIG;
 let envOptions = {
   prefix: "NITRO_",
@@ -26,7 +26,7 @@ export function useSilgiRuntimeConfig(event, inlineRuntimeConfig = {}) {
       applyEnv(klona(silgiRuntimeConfig ?? {}), envOptions)
     );
   }
-  const silgi = tryUseSilgi();
+  const silgi = tryUseSilgiApp();
   if (!silgi) {
     if (globalThis.$silgiSharedRuntimeConfig) {
       inlineRuntimeConfig = globalThis.$silgiSharedRuntimeConfig;
@@ -67,7 +67,7 @@ export function initRuntimeConfig(envOptions2 = {}, inlineRuntimeConfig = {}) {
   );
 }
 export function updateRuntimeConfig(runtimeConfig) {
-  const nuxt = useSilgi();
+  const nuxt = useSilgiApp();
   Object.assign(nuxt.options.nitro.runtimeConfig, defu(runtimeConfig, nuxt.options.nitro.runtimeConfig));
   try {
   } catch {

package/dist/runtime/internal/nitro.d.mts

@@ -1,3 +1,3 @@
 import type { Silgi } from 'silgi/types';
-export declare function addNitroApp(silgiCtx?: Silgi): Promise<void>;
+export declare function addNitroApp(silgiAppCtx?: Silgi): Promise<void>;
 export default addNitroApp;

package/dist/runtime/internal/nitro.mjs

@@ -1,7 +1,7 @@
 import { createError, defineEventHandler, getQuery, H3Error, readBody } from "h3";
-import { ErrorFactory, HttpStatus, parseURI, silgi, SilgiError, useSilgi } from "silgi";
-export async function addNitroApp(silgiCtx = useSilgi()) {
-  const nitro = silgiCtx.framework;
+import { ErrorFactory, HttpStatus, parseURI, silgi, SilgiError, useSilgiApp } from "silgi";
+export async function addNitroApp(silgiAppCtx = useSilgiApp()) {
+  const nitro = silgiAppCtx.framework;
   nitro.router.use("/srn/**", defineEventHandler(async (event) => {
     try {
       const silgiConnect = silgi(event);
@@ -13,11 +13,11 @@ export async function addNitroApp(silgiCtx = useSilgi()) {
       } else {
         newPath = `${event.path}?method=${event.method}`;
       }
-      const operation = parseURI(newPath, silgiCtx.uris);
+      const operation = parseURI(newPath, silgiAppCtx.uris);
       if (!operation) {
         throw ErrorFactory.create({ message: "Invalid URI", httpStatus: HttpStatus.BAD_REQUEST });
       }
-      await silgiCtx.callHook("event:init", event, {
+      await silgiAppCtx.callHook("event:init", event, {
         path: newPath,
         queryParams: query,
         operation

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.24.18",
+  "version": "0.24.19",
   "private": false,
   "sideEffects": false,
   "exports": {
     "./package.json": "./package.json",
     ".": "./dist/index.mjs",
     "./cli": "./dist/cli/index.mjs",
-    "./cli/config": "./dist/cli/config/index.mjs",
     "./kit": "./dist/kit/index.mjs",
     "./config": "./lib/config.mjs",
     "./types": "./dist/types/index.d.mts",

package/dist/_chunks/routeRules.mjs

@@ -1,311 +0,0 @@
-import consola from 'consola';
-import { createContext } from 'unctx';
-import { withoutTrailingSlash, withLeadingSlash } from 'ufo';
-
-const silgiCLICtx = createContext();
-function useSilgiCLI() {
-  const instance = silgiCLICtx.tryUse();
-  if (!instance) {
-    throw new Error("Silgi instance is unavailable!");
-  }
-  return instance;
-}
-async function silgiCLIIClose() {
-  const silgi = silgiCLICtx.tryUse();
-  if (!silgi) {
-    return;
-  }
-  await silgi.close();
-  await silgi.callHook("close", silgi);
-  consola.withTag("silgi").success("Process terminated");
-}
-function tryUseSilgiCLI() {
-  return silgiCLICtx.tryUse();
-}
-
-function patternToRegex(pattern) {
-  let regexStr = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
-  regexStr = regexStr.replace(/\*\*/g, ".+");
-  regexStr = regexStr.replace(/\*/g, "[^/]+");
-  regexStr = regexStr.replace(/:([^/]+)/g, "([^/]+)");
-  return new RegExp(`^${regexStr}$`);
-}
-function extractParams(url, pattern) {
-  url = withoutTrailingSlash(withLeadingSlash(url));
-  pattern = withoutTrailingSlash(withLeadingSlash(pattern));
-  if (!pattern.includes(":"))
-    return null;
-  const paramNames = [];
-  const patternRegex = pattern.replace(/:([^/]+)/g, (_, name) => {
-    paramNames.push(name);
-    return "([^/]+)";
-  });
-  const regex = new RegExp(`^${patternRegex}$`);
-  const matches = url.match(regex);
-  if (!matches)
-    return null;
-  const params = {};
-  paramNames.forEach((name, i) => {
-    params[name] = matches[i + 1];
-  });
-  return Object.keys(params).length > 0 ? params : null;
-}
-function matchesPattern(url, pattern) {
-  url = withoutTrailingSlash(withLeadingSlash(url));
-  pattern = withoutTrailingSlash(withLeadingSlash(pattern));
-  if (url === pattern)
-    return true;
-  if (pattern.endsWith("/**")) {
-    const basePath = pattern.slice(0, -3);
-    return url === basePath || url.startsWith(`${basePath}/`);
-  }
-  const urlParts = url.split("/");
-  const patternParts = pattern.split("/");
-  if (!pattern.includes("**") && urlParts.length !== patternParts.length) {
-    return false;
-  }
-  if (pattern.includes("/**/")) {
-    const [prefix, ...suffixParts] = pattern.split("/**/");
-    const suffix = suffixParts.join("/");
-    return url.startsWith(prefix) && (!suffix || url.endsWith(`/${suffix}`));
-  }
-  return patternToRegex(pattern).test(url);
-}
-function deepClone(obj) {
-  if (obj === null || typeof obj !== "object")
-    return obj;
-  if (typeof obj === "function")
-    return obj;
-  if (Array.isArray(obj))
-    return obj.map(deepClone);
-  const cloned = {};
-  for (const key in obj) {
-    if (Object.prototype.hasOwnProperty.call(obj, key)) {
-      cloned[key] = deepClone(obj[key]);
-    }
-  }
-  return cloned;
-}
-function mergeConfigs(...configs) {
-  const result = {};
-  for (const config of configs) {
-    if (!config)
-      continue;
-    for (const key in config) {
-      const value = config[key];
-      if (value && typeof value === "object" && !Array.isArray(value) && result[key] && typeof result[key] === "object" && typeof result[key] !== "function") {
-        const resultValue = result[key];
-        const valueToMerge = value;
-        result[key] = mergeConfigs(resultValue, valueToMerge);
-      } else {
-        result[key] = value;
-      }
-    }
-  }
-  return result;
-}
-function createRouteRules() {
-  let _rules = {};
-  let _mergedRules = {};
-  let _rulesModified = false;
-  function getRules() {
-    return deepClone(_rules);
-  }
-  function importRules(config) {
-    const normalizedConfig = {};
-    for (const pattern in config) {
-      normalizedConfig[withoutTrailingSlash(withLeadingSlash(pattern))] = deepClone(config[pattern]);
-    }
-    _rules = normalizedConfig;
-    _rulesModified = true;
-    updateMergeRules();
-  }
-  function exportRules() {
-    return deepClone(_rules);
-  }
-  function addRule(pattern, config) {
-    _rules[withoutTrailingSlash(withLeadingSlash(pattern))] = deepClone(config);
-    _rulesModified = true;
-    updateMergeRules();
-  }
-  function updateRule(pattern, config) {
-    const normalizedPattern = withoutTrailingSlash(withLeadingSlash(pattern));
-    if (_rules[normalizedPattern]) {
-      _rules[normalizedPattern] = { ..._rules[normalizedPattern], ...deepClone(config) };
-    } else {
-      _rules[normalizedPattern] = deepClone(config);
-    }
-    _rulesModified = true;
-    updateMergeRules();
-  }
-  function removeRule(pattern) {
-    delete _rules[withoutTrailingSlash(withLeadingSlash(pattern))];
-    _rulesModified = true;
-    updateMergeRules();
-  }
-  function matchesRule(url, pattern) {
-    return matchesPattern(withoutTrailingSlash(withLeadingSlash(url)), withoutTrailingSlash(withLeadingSlash(pattern)));
-  }
-  function getMatchingPatterns(url) {
-    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
-    return Object.keys(_rules).filter((pattern) => matchesPattern(normalizedUrl, pattern)).sort((a, b) => {
-      if (a === url)
-        return -1;
-      if (b === url)
-        return 1;
-      const aSegments = a.split("/").filter(Boolean).length;
-      const bSegments = b.split("/").filter(Boolean).length;
-      if (aSegments !== bSegments)
-        return bSegments - aSegments;
-      const aWildcards = (a.match(/\*/g) || []).length;
-      const bWildcards = (b.match(/\*/g) || []).length;
-      if (aWildcards !== bWildcards)
-        return aWildcards - bWildcards;
-      const aDoubleWildcards = (a.match(/\*\*/g) || []).length;
-      const bDoubleWildcards = (b.match(/\*\*/g) || []).length;
-      if (aDoubleWildcards !== bDoubleWildcards)
-        return aDoubleWildcards - bDoubleWildcards;
-      return b.length - a.length;
-    });
-  }
-  function getConfig(url) {
-    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
-    if (_rulesModified) {
-      updateMergeRules();
-    }
-    if (_mergedRules[normalizedUrl]) {
-      return deepClone(_mergedRules[normalizedUrl]);
-    }
-    const patterns = getMatchingPatterns(normalizedUrl);
-    if (!patterns.length)
-      return null;
-    const mergedConfig = {};
-    for (let i = patterns.length - 1; i >= 0; i--) {
-      const pattern = patterns[i];
-      const patternConfig = _mergedRules[pattern] || _rules[pattern];
-      Object.assign(mergedConfig, deepClone(patternConfig));
-    }
-    _mergedRules[normalizedUrl] = deepClone(mergedConfig);
-    return mergedConfig;
-  }
-  function computeMergedConfig(url, patterns) {
-    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
-    const matchingPatterns = patterns || getMatchingPatterns(normalizedUrl);
-    if (!matchingPatterns.length)
-      return {};
-    const allPatternsHaveCache = matchingPatterns.every((pattern) => !!_mergedRules[pattern]);
-    if (allPatternsHaveCache) {
-      return matchingPatterns.reduceRight((result, pattern) => mergeConfigs(result, deepClone(_mergedRules[pattern])), {});
-    }
-    return matchingPatterns.reduceRight((result, pattern) => mergeConfigs(result, deepClone(_rules[pattern])), {});
-  }
-  function getParams(url, pattern) {
-    return extractParams(withoutTrailingSlash(withLeadingSlash(url)), withoutTrailingSlash(withLeadingSlash(pattern)));
-  }
-  function match(url) {
-    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
-    const patterns = getMatchingPatterns(normalizedUrl);
-    if (!patterns.length)
-      return null;
-    const bestPattern = patterns[0];
-    return {
-      pattern: bestPattern,
-      config: deepClone(_rules[bestPattern]),
-      params: getParams(normalizedUrl, bestPattern)
-    };
-  }
-  function clear() {
-    _rules = {};
-    clearMergedRules();
-    _rulesModified = false;
-  }
-  function clearMergedRules() {
-    _mergedRules = {};
-    _rulesModified = true;
-  }
-  function precomputeMergedRules(urls) {
-    if (_rulesModified) {
-      updateMergeRules();
-    }
-    for (const url of urls) {
-      const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
-      if (!_mergedRules[normalizedUrl]) {
-        const patterns = getMatchingPatterns(normalizedUrl);
-        if (patterns.length) {
-          _mergedRules[normalizedUrl] = computeMergedConfig(normalizedUrl, patterns);
-        }
-      }
-    }
-  }
-  function setMergedRule(url, config) {
-    const normalizedUrl = withoutTrailingSlash(withLeadingSlash(url));
-    _mergedRules[normalizedUrl] = deepClone(config);
-    if (url.includes("*") || url.includes(":")) {
-      _rulesModified = false;
-    }
-  }
-  function getMergedRules() {
-    return deepClone(_mergedRules);
-  }
-  function configure(config) {
-    importRules(config);
-  }
-  function updateMergeRules() {
-    if (!_rulesModified) {
-      return _mergedRules;
-    }
-    _mergedRules = {};
-    const rulePatterns = Object.keys(_rules);
-    for (const pattern of rulePatterns) {
-      const patterns = getMatchingPatterns(pattern);
-      _mergedRules[pattern] = computeMergedConfig(pattern, patterns);
-    }
-    for (const pattern of rulePatterns) {
-      if (pattern.includes("/:")) {
-        const segments = pattern.split("/");
-        let partialPath = "";
-        for (const segment of segments) {
-          if (segment) {
-            partialPath += `/${segment}`;
-            if (segment.startsWith(":") && partialPath !== pattern) {
-              const samplePath = partialPath.replace(/:\w+/g, "sample");
-              const patterns = getMatchingPatterns(samplePath);
-              _mergedRules[samplePath] = computeMergedConfig(samplePath, patterns);
-            }
-          }
-        }
-      }
-    }
-    _rulesModified = false;
-    return _mergedRules;
-  }
-  return {
-    // Public getters that return a cloned version to prevent direct modification
-    get rules() {
-      return getRules();
-    },
-    get mergedRules() {
-      return getMergedRules();
-    },
-    // API methods
-    importRules,
-    exportRules,
-    addRule,
-    updateRule,
-    removeRule,
-    matchesRule,
-    getMatchingPatterns,
-    getConfig,
-    getParams,
-    match,
-    clear,
-    clearMergedRules,
-    precomputeMergedRules,
-    setMergedRule,
-    getMergedRules,
-    configure,
-    updateMergeRules
-  };
-}
-
-export { silgiCLIIClose as a, createRouteRules as c, silgiCLICtx as s, tryUseSilgiCLI as t, useSilgiCLI as u };

package/dist/cli/compatibility.mjs

@@ -1,30 +0,0 @@
-import satisfies from 'semver/functions/satisfies.js';
-import { useSilgiCLI } from 'silgi';
-import { version } from 'silgi/meta';
-
-const SEMANTIC_VERSION_RE = /-\d+\.[0-9a-f]+/;
-function normalizeSemanticVersion(version) {
-  return version.replace(SEMANTIC_VERSION_RE, "");
-}
-const SILGI_VERSION_RE = /^v/g;
-async function checkSilgiCompatibility(constraints, silgi = useSilgiCLI()) {
-  const issues = [];
-  if (constraints.silgi) {
-    const _silgiVersion = version.replace(SILGI_VERSION_RE, "");
-    if (!satisfies(normalizeSemanticVersion(_silgiVersion), constraints.silgi, { includePrerelease: true })) {
-      issues.push({
-        name: "silgi",
-        message: `Silgi version \`${constraints.silgi}\` is required but currently using \`${version}\``
-      });
-    }
-  }
-  await silgi.callHook("kit:compatibility", constraints, issues);
-  issues.toString = () => issues.map((issue) => ` - [${issue.name}] ${issue.message}`).join("\n");
-  return issues;
-}
-function hasInstalledModule(moduleKey, silgi = useSilgiCLI()) {
-  const find = silgi.scanModules.find(({ meta }) => meta.configKey === moduleKey);
-  return find?.installed ?? false;
-}
-
-export { checkSilgiCompatibility as c, hasInstalledModule as h };

package/dist/cli/config/index.d.mts

@@ -1,11 +0,0 @@
-import { SilgiCLIConfig, LoadConfigOptions, SilgiCLIOptions, SilgiCLI } from 'silgi/types';
-import { TSConfig } from 'pkg-types';
-
-declare function loadOptions(configOverrides?: SilgiCLIConfig, opts?: LoadConfigOptions): Promise<SilgiCLIOptions>;
-
-declare function silgiGenerateType(silgi: SilgiCLI): Promise<{
-    declarations: string[];
-    tsConfig: TSConfig;
-}>;
-
-export { loadOptions, silgiGenerateType };

package/dist/cli/config/index.mjs

@@ -1,16 +0,0 @@
-export { l as loadOptions, s as silgiGenerateType } from '../types.mjs';
-import 'c12';
-import 'compatx';
-import 'klona/full';
-import 'std-env';
-import 'consola';
-import 'consola/utils';
-import 'pathe';
-import 'escape-string-regexp';
-import 'mlly';
-import 'node:fs';
-import 'pkg-types';
-import 'silgi/kit';
-import 'silgi/runtime/meta';
-import 'ufo';
-import 'defu';