@mokup/shared 1.1.1 → 1.1.2

package/dist/module-loader.mjs

@@ -0,0 +1,83 @@
+import { writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { tmpdir } from 'node:os';
+import process from 'node:process';
+import { pathToFileURL } from 'node:url';
+import { resolve, extname } from 'pathe';
+
+function createTsxConfigFile(options) {
+  const config = {
+    compilerOptions: {
+      baseUrl: options.baseUrl,
+      paths: options.paths
+    }
+  };
+  const configPath = options.fileName ?? resolve(tmpdir(), `mokup-tsx-${process.pid}.json`);
+  writeFileSync(configPath, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  return configPath;
+}
+let sourceMapsEnabled = false;
+let tsxRegisterPromise = null;
+let tsxRegisteredConfig = null;
+function resetModuleLoaderForTests() {
+  sourceMapsEnabled = false;
+  tsxRegisterPromise = null;
+  tsxRegisteredConfig = null;
+}
+function ensureSourceMapsEnabled() {
+  if (sourceMapsEnabled) {
+    return;
+  }
+  const setSourceMapsEnabled = process.setSourceMapsEnabled;
+  if (typeof setSourceMapsEnabled === "function") {
+    setSourceMapsEnabled(true);
+  }
+  sourceMapsEnabled = true;
+}
+async function ensureTsxRegister(tsconfigPath) {
+  const desired = tsconfigPath ?? null;
+  if (tsxRegisterPromise) {
+    await tsxRegisterPromise;
+    if (desired && tsxRegisteredConfig !== desired) {
+      tsxRegisterPromise = (async () => {
+        ensureSourceMapsEnabled();
+        const { register } = await import('tsx/esm/api');
+        register({ tsconfig: desired });
+        tsxRegisteredConfig = desired;
+      })();
+      await tsxRegisterPromise;
+    }
+    return tsxRegisterPromise;
+  }
+  tsxRegisterPromise = (async () => {
+    ensureSourceMapsEnabled();
+    const { register } = await import('tsx/esm/api');
+    if (desired) {
+      register({ tsconfig: desired });
+      tsxRegisteredConfig = desired;
+    } else {
+      register();
+      tsxRegisteredConfig = null;
+    }
+  })();
+  return tsxRegisterPromise;
+}
+async function loadModule(file, options) {
+  const ext = extname(file).toLowerCase();
+  if (ext === ".cjs") {
+    const require = createRequire(import.meta.url);
+    delete require.cache[file];
+    return require(file);
+  }
+  if (ext === ".js" || ext === ".mjs") {
+    return import(`${pathToFileURL(file).href}?t=${Date.now()}`);
+  }
+  if (ext === ".ts") {
+    await ensureTsxRegister(options?.tsconfigPath ?? null);
+    return import(`${pathToFileURL(file).href}?t=${Date.now()}`);
+  }
+  return null;
+}
+
+export { createTsxConfigFile, ensureTsxRegister, loadModule, resetModuleLoaderForTests };

package/dist/path-utils.cjs

@@ -1,10 +1,10 @@
 'use strict';
 
-const node_process = require('node:process');
+const process = require('node:process');
 const pathe = require('pathe');
 
 function isWindowsLikePath(normalized) {
-  return node_process.platform === "win32" || /^[a-z]:\//i.test(normalized) || normalized.startsWith("//");
+  return process.platform === "win32" || /^[a-z]:\//i.test(normalized) || normalized.startsWith("//");
 }
 function toPosix(value) {
   return value.replace(/\\/g, "/");

package/dist/playground-grouping.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-const node_process = require('node:process');
+const process = require('node:process');
 const pathe = require('pathe');
 const pathUtils = require('./path-utils.cjs');
 
@@ -14,7 +14,7 @@ function isAncestor(parent, child) {
 }
 function resolveGroupRoot(dirs, serverRoot) {
   if (!dirs || dirs.length === 0) {
-    return serverRoot ?? node_process.cwd();
+    return serverRoot ?? process.cwd();
   }
   if (serverRoot) {
     const normalizedRoot = normalizePath(serverRoot);
@@ -38,7 +38,7 @@ function resolveGroupRoot(dirs, serverRoot) {
     }
   }
   if (!common || common === "/") {
-    return serverRoot ?? node_process.cwd();
+    return serverRoot ?? process.cwd();
   }
   return common;
 }

package/dist/route-constants.cjs

@@ -0,0 +1,30 @@
+'use strict';
+
+const methodSet = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "HEAD"
+]);
+const methodSuffixSet = new Set(
+  Array.from(methodSet, (method) => method.toLowerCase())
+);
+const supportedExtensions = /* @__PURE__ */ new Set([
+  ".json",
+  ".jsonc",
+  ".ts",
+  ".js",
+  ".mjs",
+  ".cjs"
+]);
+const configExtensions = [".ts", ".js", ".mjs", ".cjs"];
+const jsonExtensions = /* @__PURE__ */ new Set([".json", ".jsonc"]);
+
+exports.configExtensions = configExtensions;
+exports.jsonExtensions = jsonExtensions;
+exports.methodSet = methodSet;
+exports.methodSuffixSet = methodSuffixSet;
+exports.supportedExtensions = supportedExtensions;

package/dist/route-constants.d.cts

@@ -0,0 +1,7 @@
+declare const methodSet: Set<string>;
+declare const methodSuffixSet: Set<string>;
+declare const supportedExtensions: Set<string>;
+declare const configExtensions: readonly [".ts", ".js", ".mjs", ".cjs"];
+declare const jsonExtensions: Set<string>;
+
+export { configExtensions, jsonExtensions, methodSet, methodSuffixSet, supportedExtensions };

package/dist/route-constants.d.mts

@@ -0,0 +1,7 @@
+declare const methodSet: Set<string>;
+declare const methodSuffixSet: Set<string>;
+declare const supportedExtensions: Set<string>;
+declare const configExtensions: readonly [".ts", ".js", ".mjs", ".cjs"];
+declare const jsonExtensions: Set<string>;
+
+export { configExtensions, jsonExtensions, methodSet, methodSuffixSet, supportedExtensions };

package/dist/route-constants.d.ts

@@ -0,0 +1,7 @@
+declare const methodSet: Set<string>;
+declare const methodSuffixSet: Set<string>;
+declare const supportedExtensions: Set<string>;
+declare const configExtensions: readonly [".ts", ".js", ".mjs", ".cjs"];
+declare const jsonExtensions: Set<string>;
+
+export { configExtensions, jsonExtensions, methodSet, methodSuffixSet, supportedExtensions };

package/dist/route-constants.mjs

@@ -0,0 +1,24 @@
+const methodSet = /* @__PURE__ */ new Set([
+  "GET",
+  "POST",
+  "PUT",
+  "PATCH",
+  "DELETE",
+  "OPTIONS",
+  "HEAD"
+]);
+const methodSuffixSet = new Set(
+  Array.from(methodSet, (method) => method.toLowerCase())
+);
+const supportedExtensions = /* @__PURE__ */ new Set([
+  ".json",
+  ".jsonc",
+  ".ts",
+  ".js",
+  ".mjs",
+  ".cjs"
+]);
+const configExtensions = [".ts", ".js", ".mjs", ".cjs"];
+const jsonExtensions = /* @__PURE__ */ new Set([".json", ".jsonc"]);
+
+export { configExtensions, jsonExtensions, methodSet, methodSuffixSet, supportedExtensions };

package/dist/route-utils.cjs

@@ -0,0 +1,126 @@
+'use strict';
+
+const pathUtils = require('./path-utils.cjs');
+const pathe = require('pathe');
+const routeConstants = require('./route-constants.cjs');
+const scanUtils = require('./scan-utils.cjs');
+require('node:process');
+
+function createRouteUtils(params) {
+  const { parseRouteTemplate, compareRouteScore } = params;
+  function resolveTemplate(template, prefix) {
+    const normalized = template.startsWith("/") ? template : `/${template}`;
+    if (!prefix) {
+      return normalized;
+    }
+    const normalizedPrefix = scanUtils.normalizePrefix(prefix);
+    if (!normalizedPrefix) {
+      return normalized;
+    }
+    if (normalized === normalizedPrefix || normalized.startsWith(`${normalizedPrefix}/`)) {
+      return normalized;
+    }
+    if (normalized === "/") {
+      return `${normalizedPrefix}/`;
+    }
+    return `${normalizedPrefix}${normalized}`;
+  }
+  function stripMethodSuffix(base) {
+    const segments = base.split(".");
+    const last = segments.at(-1);
+    if (last && routeConstants.methodSuffixSet.has(last.toLowerCase())) {
+      segments.pop();
+      return {
+        name: segments.join("."),
+        method: last.toUpperCase()
+      };
+    }
+    return {
+      name: base,
+      method: void 0
+    };
+  }
+  function deriveRouteFromFile(file, rootDir, warn) {
+    const rel = pathUtils.toPosix(pathe.relative(rootDir, file));
+    const ext = pathe.extname(rel);
+    const withoutExt = rel.slice(0, rel.length - ext.length);
+    const dir = pathe.dirname(withoutExt);
+    const base = pathe.basename(withoutExt);
+    const { name, method } = stripMethodSuffix(base);
+    const resolvedMethod = method ?? (routeConstants.jsonExtensions.has(ext) ? "GET" : void 0);
+    if (!resolvedMethod) {
+      warn?.(`Skip mock without method suffix: ${file}`);
+      return null;
+    }
+    if (!name) {
+      warn?.(`Skip mock with empty route name: ${file}`);
+      return null;
+    }
+    const joined = dir === "." ? name : pathe.join(dir, name);
+    const segments = pathUtils.toPosix(joined).split("/");
+    if (segments.at(-1) === "index") {
+      segments.pop();
+    }
+    const template = segments.length === 0 ? "/" : `/${segments.join("/")}`;
+    const parsed = parseRouteTemplate(template);
+    if (parsed.errors.length > 0) {
+      for (const error of parsed.errors) {
+        warn?.(`${error} in ${file}`);
+      }
+      return null;
+    }
+    for (const warning of parsed.warnings) {
+      warn?.(`${warning} in ${file}`);
+    }
+    return {
+      template: parsed.template,
+      method: resolvedMethod,
+      tokens: parsed.tokens,
+      score: parsed.score
+    };
+  }
+  function resolveRule(input) {
+    const method = input.derivedMethod;
+    if (!method) {
+      input.warn?.(`Skip mock without method suffix: ${input.file}`);
+      return null;
+    }
+    const template = resolveTemplate(input.derivedTemplate, input.prefix);
+    const parsed = parseRouteTemplate(template);
+    if (parsed.errors.length > 0) {
+      for (const error of parsed.errors) {
+        input.warn?.(`${error} in ${input.file}`);
+      }
+      return null;
+    }
+    for (const warning of parsed.warnings) {
+      input.warn?.(`${warning} in ${input.file}`);
+    }
+    const base = {
+      template: parsed.template,
+      method,
+      tokens: parsed.tokens,
+      score: parsed.score
+    };
+    return input.build ? input.build(base, input.rule) : base;
+  }
+  function sortRoutes(routes) {
+    return routes.sort((a, b) => {
+      if (a.method !== b.method) {
+        return a.method.localeCompare(b.method);
+      }
+      const scoreCompare = compareRouteScore(a.score, b.score);
+      if (scoreCompare !== 0) {
+        return scoreCompare;
+      }
+      return a.template.localeCompare(b.template);
+    });
+  }
+  return {
+    deriveRouteFromFile,
+    resolveRule,
+    sortRoutes
+  };
+}
+
+exports.createRouteUtils = createRouteUtils;

package/dist/route-utils.d.cts

@@ -0,0 +1,42 @@
+interface RouteParserResult<TToken = unknown> {
+    template: string;
+    tokens: TToken[];
+    score: number[];
+    errors: string[];
+    warnings: string[];
+}
+type RouteParser<TToken = unknown> = (template: string) => RouteParserResult<TToken>;
+type RouteScoreComparator = (a: number[], b: number[]) => number;
+interface DerivedRoute<TToken = unknown> {
+    template: string;
+    method: string;
+    tokens: TToken[];
+    score: number[];
+}
+declare function createRouteUtils<TToken = unknown, TRule extends {
+    handler: unknown;
+} = {
+    handler: unknown;
+}>(params: {
+    parseRouteTemplate: RouteParser<TToken>;
+    compareRouteScore: RouteScoreComparator;
+}): {
+    deriveRouteFromFile: (file: string, rootDir: string, warn?: (message: string) => void) => DerivedRoute<TToken> | null;
+    resolveRule: <TOutput = DerivedRoute<TToken>>(input: {
+        rule: TRule;
+        derivedTemplate: string;
+        derivedMethod?: string;
+        prefix: string;
+        file: string;
+        warn?: (message: string) => void;
+        build?: (base: DerivedRoute<TToken>, rule: TRule) => TOutput;
+    }) => TOutput | null;
+    sortRoutes: <TRoute extends {
+        method: string;
+        score: number[];
+        template: string;
+    }>(routes: TRoute[]) => TRoute[];
+};
+
+export { createRouteUtils };
+export type { DerivedRoute, RouteParser, RouteParserResult, RouteScoreComparator };

package/dist/route-utils.d.mts

@@ -0,0 +1,42 @@
+interface RouteParserResult<TToken = unknown> {
+    template: string;
+    tokens: TToken[];
+    score: number[];
+    errors: string[];
+    warnings: string[];
+}
+type RouteParser<TToken = unknown> = (template: string) => RouteParserResult<TToken>;
+type RouteScoreComparator = (a: number[], b: number[]) => number;
+interface DerivedRoute<TToken = unknown> {
+    template: string;
+    method: string;
+    tokens: TToken[];
+    score: number[];
+}
+declare function createRouteUtils<TToken = unknown, TRule extends {
+    handler: unknown;
+} = {
+    handler: unknown;
+}>(params: {
+    parseRouteTemplate: RouteParser<TToken>;
+    compareRouteScore: RouteScoreComparator;
+}): {
+    deriveRouteFromFile: (file: string, rootDir: string, warn?: (message: string) => void) => DerivedRoute<TToken> | null;
+    resolveRule: <TOutput = DerivedRoute<TToken>>(input: {
+        rule: TRule;
+        derivedTemplate: string;
+        derivedMethod?: string;
+        prefix: string;
+        file: string;
+        warn?: (message: string) => void;
+        build?: (base: DerivedRoute<TToken>, rule: TRule) => TOutput;
+    }) => TOutput | null;
+    sortRoutes: <TRoute extends {
+        method: string;
+        score: number[];
+        template: string;
+    }>(routes: TRoute[]) => TRoute[];
+};
+
+export { createRouteUtils };
+export type { DerivedRoute, RouteParser, RouteParserResult, RouteScoreComparator };

package/dist/route-utils.d.ts

@@ -0,0 +1,42 @@
+interface RouteParserResult<TToken = unknown> {
+    template: string;
+    tokens: TToken[];
+    score: number[];
+    errors: string[];
+    warnings: string[];
+}
+type RouteParser<TToken = unknown> = (template: string) => RouteParserResult<TToken>;
+type RouteScoreComparator = (a: number[], b: number[]) => number;
+interface DerivedRoute<TToken = unknown> {
+    template: string;
+    method: string;
+    tokens: TToken[];
+    score: number[];
+}
+declare function createRouteUtils<TToken = unknown, TRule extends {
+    handler: unknown;
+} = {
+    handler: unknown;
+}>(params: {
+    parseRouteTemplate: RouteParser<TToken>;
+    compareRouteScore: RouteScoreComparator;
+}): {
+    deriveRouteFromFile: (file: string, rootDir: string, warn?: (message: string) => void) => DerivedRoute<TToken> | null;
+    resolveRule: <TOutput = DerivedRoute<TToken>>(input: {
+        rule: TRule;
+        derivedTemplate: string;
+        derivedMethod?: string;
+        prefix: string;
+        file: string;
+        warn?: (message: string) => void;
+        build?: (base: DerivedRoute<TToken>, rule: TRule) => TOutput;
+    }) => TOutput | null;
+    sortRoutes: <TRoute extends {
+        method: string;
+        score: number[];
+        template: string;
+    }>(routes: TRoute[]) => TRoute[];
+};
+
+export { createRouteUtils };
+export type { DerivedRoute, RouteParser, RouteParserResult, RouteScoreComparator };

package/dist/route-utils.mjs

@@ -0,0 +1,124 @@
+import { toPosix } from './path-utils.mjs';
+import { relative, extname, dirname, basename, join } from 'pathe';
+import { jsonExtensions, methodSuffixSet } from './route-constants.mjs';
+import { normalizePrefix } from './scan-utils.mjs';
+import 'node:process';
+
+function createRouteUtils(params) {
+  const { parseRouteTemplate, compareRouteScore } = params;
+  function resolveTemplate(template, prefix) {
+    const normalized = template.startsWith("/") ? template : `/${template}`;
+    if (!prefix) {
+      return normalized;
+    }
+    const normalizedPrefix = normalizePrefix(prefix);
+    if (!normalizedPrefix) {
+      return normalized;
+    }
+    if (normalized === normalizedPrefix || normalized.startsWith(`${normalizedPrefix}/`)) {
+      return normalized;
+    }
+    if (normalized === "/") {
+      return `${normalizedPrefix}/`;
+    }
+    return `${normalizedPrefix}${normalized}`;
+  }
+  function stripMethodSuffix(base) {
+    const segments = base.split(".");
+    const last = segments.at(-1);
+    if (last && methodSuffixSet.has(last.toLowerCase())) {
+      segments.pop();
+      return {
+        name: segments.join("."),
+        method: last.toUpperCase()
+      };
+    }
+    return {
+      name: base,
+      method: void 0
+    };
+  }
+  function deriveRouteFromFile(file, rootDir, warn) {
+    const rel = toPosix(relative(rootDir, file));
+    const ext = extname(rel);
+    const withoutExt = rel.slice(0, rel.length - ext.length);
+    const dir = dirname(withoutExt);
+    const base = basename(withoutExt);
+    const { name, method } = stripMethodSuffix(base);
+    const resolvedMethod = method ?? (jsonExtensions.has(ext) ? "GET" : void 0);
+    if (!resolvedMethod) {
+      warn?.(`Skip mock without method suffix: ${file}`);
+      return null;
+    }
+    if (!name) {
+      warn?.(`Skip mock with empty route name: ${file}`);
+      return null;
+    }
+    const joined = dir === "." ? name : join(dir, name);
+    const segments = toPosix(joined).split("/");
+    if (segments.at(-1) === "index") {
+      segments.pop();
+    }
+    const template = segments.length === 0 ? "/" : `/${segments.join("/")}`;
+    const parsed = parseRouteTemplate(template);
+    if (parsed.errors.length > 0) {
+      for (const error of parsed.errors) {
+        warn?.(`${error} in ${file}`);
+      }
+      return null;
+    }
+    for (const warning of parsed.warnings) {
+      warn?.(`${warning} in ${file}`);
+    }
+    return {
+      template: parsed.template,
+      method: resolvedMethod,
+      tokens: parsed.tokens,
+      score: parsed.score
+    };
+  }
+  function resolveRule(input) {
+    const method = input.derivedMethod;
+    if (!method) {
+      input.warn?.(`Skip mock without method suffix: ${input.file}`);
+      return null;
+    }
+    const template = resolveTemplate(input.derivedTemplate, input.prefix);
+    const parsed = parseRouteTemplate(template);
+    if (parsed.errors.length > 0) {
+      for (const error of parsed.errors) {
+        input.warn?.(`${error} in ${input.file}`);
+      }
+      return null;
+    }
+    for (const warning of parsed.warnings) {
+      input.warn?.(`${warning} in ${input.file}`);
+    }
+    const base = {
+      template: parsed.template,
+      method,
+      tokens: parsed.tokens,
+      score: parsed.score
+    };
+    return input.build ? input.build(base, input.rule) : base;
+  }
+  function sortRoutes(routes) {
+    return routes.sort((a, b) => {
+      if (a.method !== b.method) {
+        return a.method.localeCompare(b.method);
+      }
+      const scoreCompare = compareRouteScore(a.score, b.score);
+      if (scoreCompare !== 0) {
+        return scoreCompare;
+      }
+      return a.template.localeCompare(b.template);
+    });
+  }
+  return {
+    deriveRouteFromFile,
+    resolveRule,
+    sortRoutes
+  };
+}
+
+export { createRouteUtils };

package/dist/scan-utils.cjs

@@ -0,0 +1,39 @@
+'use strict';
+
+const pathe = require('pathe');
+const routeConstants = require('./route-constants.cjs');
+
+function normalizeMethod(method) {
+  if (!method) {
+    return void 0;
+  }
+  const normalized = method.toUpperCase();
+  if (routeConstants.methodSet.has(normalized)) {
+    return normalized;
+  }
+  return void 0;
+}
+function normalizePrefix(prefix) {
+  if (!prefix) {
+    return "";
+  }
+  const normalized = prefix.startsWith("/") ? prefix : `/${prefix}`;
+  return normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+}
+function resolveDirs(dir, root) {
+  const raw = typeof dir === "function" ? dir(root) : dir;
+  const resolved = Array.isArray(raw) ? raw : raw ? [raw] : ["mock"];
+  const normalized = resolved.map(
+    (entry) => pathe.isAbsolute(entry) ? entry : pathe.resolve(root, entry)
+  );
+  return Array.from(new Set(normalized));
+}
+function normalizeIgnorePrefix(value, fallback = ["."]) {
+  const list = typeof value === "undefined" ? fallback : Array.isArray(value) ? value : [value];
+  return list.filter((entry) => typeof entry === "string" && entry.length > 0);
+}
+
+exports.normalizeIgnorePrefix = normalizeIgnorePrefix;
+exports.normalizeMethod = normalizeMethod;
+exports.normalizePrefix = normalizePrefix;
+exports.resolveDirs = resolveDirs;