silgi 0.27.5 → 0.27.6

package/dist/_chunks/silgiApp.mjs

@@ -1,6 +1,292 @@
+import { withoutTrailingSlash, withLeadingSlash } from 'ufo';
 import consola from 'consola';
 import { getContext } from 'unctx';
 
+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
+  };
+}
+
 const silgiCLICtx = getContext("silgiCLI");
 function useSilgiCLI() {
   const instance = silgiCLICtx.tryUse();
@@ -22,4 +308,4 @@ function tryUseSilgiCLI() {
   return silgiCLICtx.tryUse();
 }
 
-export { silgiCLIIClose as a, silgiCLICtx as s, tryUseSilgiCLI as t, useSilgiCLI as u };
+export { silgiCLIIClose as a, createRouteRules as c, silgiCLICtx as s, tryUseSilgiCLI as t, useSilgiCLI as u };

package/dist/build.d.mts

@@ -1,18 +1,5 @@
-import { SilgiCLI, SilgiCLIConfig, LoadConfigOptions } from 'silgi/types';
+import { SilgiCLI } from 'silgi/types';
 
-/**
- * Prepares route rules for the build
- */
-declare function prepareBuild(silgi: SilgiCLI): Promise<void>;
+declare function build(silgi: SilgiCLI): Promise<void>;
 
-declare function generateApiFul(silgi: SilgiCLI): Promise<void>;
-
-declare function prepare(_silgi: SilgiCLI): Promise<void>;
-
-declare function createSilgiCLI(config?: SilgiCLIConfig, opts?: LoadConfigOptions): Promise<SilgiCLI>;
-
-declare function writeCoreFile(silgi: SilgiCLI): Promise<void>;
-
-declare function writeTypesAndFiles(silgi: SilgiCLI): Promise<void>;
-
-export { createSilgiCLI, generateApiFul, prepare, prepareBuild, writeCoreFile, writeTypesAndFiles };
+export { build };

package/dist/build.mjs

@@ -1,41 +1,17 @@
-export { c as createSilgiCLI, g as generateApiFul, a as prepare, p as prepareBuild, w as writeCoreFile, b as writeTypesAndFiles } from './cli/writeTypesAndFiles.mjs';
-import 'knitwork';
-import 'pathe';
-import 'silgi/kit';
+export { b as build } from './cli/build.mjs';
 import 'apiful/openapi';
 import 'consola';
+import 'pathe';
+import 'silgi/kit';
 import 'node:fs';
 import 'node:fs/promises';
-import 'hookable';
-import 'silgi';
+import 'knitwork';
+import 'mlly';
+import 'pathe/utils';
 import 'silgi/runtime/meta';
 import 'unimport';
-import './_chunks/routeRules.mjs';
-import 'ufo';
-import '@clack/prompts';
-import 'dotenv';
-import 'mlly';
-import 'dev-jiti';
-import './cli/compatibility.mjs';
-import 'semver/functions/satisfies.js';
-import 'silgi/meta';
-import 'node:url';
-import 'defu';
-import 'exsolve';
 import 'untyped';
-import 'globby';
-import 'ignore';
-import '@oxc-parser/wasm';
-import 'klona';
-import 'silgi/runtime';
-import 'unstorage';
-import 'scule';
 import './cli/types.mjs';
-import 'c12';
-import 'compatx';
-import 'klona/full';
-import 'std-env';
-import 'consola/utils';
-import 'escape-string-regexp';
+import 'defu';
 import 'pkg-types';
-import 'pathe/utils';
+import 'ufo';