silgi 0.14.4 → 0.16.0

package/dist/_chunks/index.mjs

@@ -1,4 +1,4 @@
-const version = "0.14.4";
+const version = "0.16.0";
 const peerDependencies = {
 	"@fastify/deepmerge": "^2.0.2",
 	"@nuxt/kit": "^3.15.3",

package/dist/_chunks/routeRules.mjs

@@ -0,0 +1,274 @@
+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) {
+  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) {
+  if (url === pattern)
+    return true;
+  if (url.endsWith("/") && !pattern.endsWith("/") || !url.endsWith("/") && pattern.endsWith("/")) {
+    return false;
+  }
+  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) {
+    _rules = deepClone(config);
+    _rulesModified = true;
+    updateMergeRules();
+  }
+  function exportRules() {
+    return deepClone(_rules);
+  }
+  function addRule(pattern, config) {
+    _rules[pattern] = deepClone(config);
+    _rulesModified = true;
+    updateMergeRules();
+  }
+  function updateRule(pattern, config) {
+    if (_rules[pattern]) {
+      _rules[pattern] = { ..._rules[pattern], ...deepClone(config) };
+    } else {
+      _rules[pattern] = deepClone(config);
+    }
+    _rulesModified = true;
+    updateMergeRules();
+  }
+  function removeRule(pattern) {
+    delete _rules[pattern];
+    _rulesModified = true;
+    updateMergeRules();
+  }
+  function matchesRule(url, pattern) {
+    return matchesPattern(url, pattern);
+  }
+  function getMatchingPatterns(url) {
+    return Object.keys(_rules).filter((pattern) => matchesPattern(url, 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) {
+    if (_rulesModified) {
+      updateMergeRules();
+    }
+    if (_mergedRules[url]) {
+      return deepClone(_mergedRules[url]);
+    }
+    const patterns = getMatchingPatterns(url);
+    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[url] = deepClone(mergedConfig);
+    return mergedConfig;
+  }
+  function computeMergedConfig(url, patterns) {
+    const matchingPatterns = patterns || getMatchingPatterns(url);
+    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(url, pattern);
+  }
+  function match(url) {
+    const patterns = getMatchingPatterns(url);
+    if (!patterns.length)
+      return null;
+    const bestPattern = patterns[0];
+    return {
+      pattern: bestPattern,
+      config: deepClone(_rules[bestPattern]),
+      params: getParams(url, bestPattern)
+    };
+  }
+  function clear() {
+    _rules = {};
+    clearMergedRules();
+    _rulesModified = false;
+  }
+  function clearMergedRules() {
+    _mergedRules = {};
+    _rulesModified = true;
+  }
+  function precomputeMergedRules(urls) {
+    if (_rulesModified) {
+      updateMergeRules();
+    }
+    for (const url of urls) {
+      if (!_mergedRules[url]) {
+        const patterns = getMatchingPatterns(url);
+        if (patterns.length) {
+          _mergedRules[url] = computeMergedConfig(url, patterns);
+        }
+      }
+    }
+  }
+  function setMergedRule(url, config) {
+    _mergedRules[url] = 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 { createRouteRules as c };

package/dist/cli/dev.mjs

@@ -15,6 +15,7 @@ import 'silgi/kit';
 import 'silgi/runtime/meta';
 import 'silgi/types';
 import 'unimport';
+import '../_chunks/routeRules.mjs';
 import './env.mjs';
 import '@clack/prompts';
 import 'dotenv';

package/dist/cli/loader.mjs

@@ -27,6 +27,7 @@ const SilgiCLIDefaults = {
       version: "0.0.1"
     }
   },
+  serviceParseModules: [],
   storages: [],
   devServer: {
     watch: []
@@ -56,6 +57,7 @@ const SilgiCLIDefaults = {
   // Modules
   _modules: [],
   modules: [],
+  routeRules: {},
   // Features
   // experimental: {},
   future: {},
@@ -92,7 +94,6 @@ const SilgiCLIDefaults = {
   // handlers: [],
   // devHandlers: [],
   // errorHandler: undefined,
-  // routeRules: {},
   // Advanced
   typescript: {
     strict: false,

package/dist/cli/prepare.mjs

@@ -1,17 +1,18 @@
 import { defineCommand } from 'citty';
 import consola from 'consola';
-import { resolve } from 'pathe';
+import { join, resolve } from 'pathe';
 import { version } from 'silgi/meta';
+import { writeFile } from 'silgi/kit';
 import { c as createSilgiCLI, p as prepare$1, w as writeTypesAndFiles, a as writeCoreFile } from './writeTypesAndFiles.mjs';
 import { c as commonArgs } from './common.mjs';
 import 'node:fs';
 import 'node:fs/promises';
 import 'hookable';
 import 'silgi/core';
-import 'silgi/kit';
 import 'silgi/runtime/meta';
 import 'silgi/types';
 import 'unimport';
+import '../_chunks/routeRules.mjs';
 import './env.mjs';
 import '@clack/prompts';
 import 'dotenv';
@@ -39,6 +40,48 @@ import 'pathe/utils';
 import 'untyped';
 import './types.mjs';
 
+function serializeToString(obj, indent = 0) {
+  const spacing = " ".repeat(indent);
+  const innerSpacing = " ".repeat(indent + 4);
+  if (obj === null || obj === void 0)
+    return "null";
+  if (typeof obj === "function")
+    return obj.toString();
+  if (typeof obj !== "object")
+    return JSON.stringify(obj);
+  if (Array.isArray(obj)) {
+    if (obj.length === 0)
+      return "[]";
+    const items = obj.map((item) => serializeToString(item, indent + 4));
+    return `[
+${innerSpacing}${items.join(`,
+${innerSpacing}`)}
+${spacing}]`;
+  }
+  const entries = Object.entries(obj);
+  if (entries.length === 0)
+    return "{}";
+  const props = entries.map(
+    ([key, value]) => `${innerSpacing}"${key}": ${serializeToString(value, indent + 4)}`
+  );
+  return `{
+${props.join(",\n")}
+${spacing}}`;
+}
+async function prepareBuild(silgi) {
+  const exportedRules = silgi.routeRules.exportRules();
+  const serialized = serializeToString(exportedRules);
+  const content = `/* eslint-disable */
+// @ts-nocheck
+// This file is auto-generated at build time
+// Contains route rules with preserved functions
+
+export const routeRules = ${serialized}
+`;
+  const file = join(silgi.options.silgi.serverDir, "rules.ts");
+  await writeFile(file, content);
+}
+
 const prepare = defineCommand({
   meta: {
     name: "prepare",
@@ -73,6 +116,7 @@ const prepare = defineCommand({
     await prepare$1();
     await writeTypesAndFiles(silgi);
     await writeCoreFile(silgi);
+    await prepareBuild(silgi);
     const close = async () => {
       await silgi.close();
       await silgi.callHook("close", silgi);