@mokup/shared 1.1.0 → 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

@@ -0,0 +1,57 @@
+'use strict';
+
+const process = require('node:process');
+const pathe = require('pathe');
+
+function isWindowsLikePath(normalized) {
+  return process.platform === "win32" || /^[a-z]:\//i.test(normalized) || normalized.startsWith("//");
+}
+function toPosix(value) {
+  return value.replace(/\\/g, "/");
+}
+function normalizePath(value) {
+  return pathe.normalize(toPosix(value));
+}
+function normalizePathForComparison(value) {
+  const normalized = normalizePath(value);
+  return isWindowsLikePath(normalized) ? normalized.toLowerCase() : normalized;
+}
+function isInDirs(file, dirs) {
+  const normalized = normalizePathForComparison(file);
+  return dirs.some((dir) => {
+    const normalizedDir = normalizePathForComparison(dir).replace(/\/$/, "");
+    return normalized === normalizedDir || normalized.startsWith(`${normalizedDir}/`);
+  });
+}
+function testPatterns(patterns, value) {
+  const list = Array.isArray(patterns) ? patterns : [patterns];
+  return list.some((pattern) => pattern.test(value));
+}
+function matchesFilter(file, include, exclude) {
+  const normalized = normalizePathForComparison(file);
+  if (exclude && testPatterns(exclude, normalized)) {
+    return false;
+  }
+  if (include) {
+    return testPatterns(include, normalized);
+  }
+  return true;
+}
+function hasIgnoredPrefix(file, rootDir, prefixes) {
+  if (prefixes.length === 0) {
+    return false;
+  }
+  const normalizedRoot = normalizePathForComparison(rootDir);
+  const normalizedFile = normalizePathForComparison(file);
+  const relativePath = toPosix(pathe.relative(normalizedRoot, normalizedFile));
+  const segments = relativePath.split("/");
+  return segments.some(
+    (segment) => prefixes.some((prefix) => segment.startsWith(prefix))
+  );
+}
+
+exports.hasIgnoredPrefix = hasIgnoredPrefix;
+exports.isInDirs = isInDirs;
+exports.matchesFilter = matchesFilter;
+exports.normalizePathForComparison = normalizePathForComparison;
+exports.toPosix = toPosix;

package/dist/path-utils.d.cts

@@ -0,0 +1,7 @@
+declare function toPosix(value: string): string;
+declare function normalizePathForComparison(value: string): string;
+declare function isInDirs(file: string, dirs: string[]): boolean;
+declare function matchesFilter(file: string, include?: RegExp | RegExp[], exclude?: RegExp | RegExp[]): boolean;
+declare function hasIgnoredPrefix(file: string, rootDir: string, prefixes: string[]): boolean;
+
+export { hasIgnoredPrefix, isInDirs, matchesFilter, normalizePathForComparison, toPosix };

package/dist/path-utils.d.mts

@@ -0,0 +1,7 @@
+declare function toPosix(value: string): string;
+declare function normalizePathForComparison(value: string): string;
+declare function isInDirs(file: string, dirs: string[]): boolean;
+declare function matchesFilter(file: string, include?: RegExp | RegExp[], exclude?: RegExp | RegExp[]): boolean;
+declare function hasIgnoredPrefix(file: string, rootDir: string, prefixes: string[]): boolean;
+
+export { hasIgnoredPrefix, isInDirs, matchesFilter, normalizePathForComparison, toPosix };

package/dist/path-utils.d.ts

@@ -0,0 +1,7 @@
+declare function toPosix(value: string): string;
+declare function normalizePathForComparison(value: string): string;
+declare function isInDirs(file: string, dirs: string[]): boolean;
+declare function matchesFilter(file: string, include?: RegExp | RegExp[], exclude?: RegExp | RegExp[]): boolean;
+declare function hasIgnoredPrefix(file: string, rootDir: string, prefixes: string[]): boolean;
+
+export { hasIgnoredPrefix, isInDirs, matchesFilter, normalizePathForComparison, toPosix };

package/dist/path-utils.mjs

@@ -0,0 +1,51 @@
+import { platform } from 'node:process';
+import { relative, normalize } from 'pathe';
+
+function isWindowsLikePath(normalized) {
+  return platform === "win32" || /^[a-z]:\//i.test(normalized) || normalized.startsWith("//");
+}
+function toPosix(value) {
+  return value.replace(/\\/g, "/");
+}
+function normalizePath(value) {
+  return normalize(toPosix(value));
+}
+function normalizePathForComparison(value) {
+  const normalized = normalizePath(value);
+  return isWindowsLikePath(normalized) ? normalized.toLowerCase() : normalized;
+}
+function isInDirs(file, dirs) {
+  const normalized = normalizePathForComparison(file);
+  return dirs.some((dir) => {
+    const normalizedDir = normalizePathForComparison(dir).replace(/\/$/, "");
+    return normalized === normalizedDir || normalized.startsWith(`${normalizedDir}/`);
+  });
+}
+function testPatterns(patterns, value) {
+  const list = Array.isArray(patterns) ? patterns : [patterns];
+  return list.some((pattern) => pattern.test(value));
+}
+function matchesFilter(file, include, exclude) {
+  const normalized = normalizePathForComparison(file);
+  if (exclude && testPatterns(exclude, normalized)) {
+    return false;
+  }
+  if (include) {
+    return testPatterns(include, normalized);
+  }
+  return true;
+}
+function hasIgnoredPrefix(file, rootDir, prefixes) {
+  if (prefixes.length === 0) {
+    return false;
+  }
+  const normalizedRoot = normalizePathForComparison(rootDir);
+  const normalizedFile = normalizePathForComparison(file);
+  const relativePath = toPosix(relative(normalizedRoot, normalizedFile));
+  const segments = relativePath.split("/");
+  return segments.some(
+    (segment) => prefixes.some((prefix) => segment.startsWith(prefix))
+  );
+}
+
+export { hasIgnoredPrefix, isInDirs, matchesFilter, normalizePathForComparison, toPosix };

package/dist/playground-grouping.cjs

@@ -0,0 +1,95 @@
+'use strict';
+
+const process = require('node:process');
+const pathe = require('pathe');
+const pathUtils = require('./path-utils.cjs');
+
+function normalizePath(value) {
+  return pathe.normalize(pathUtils.toPosix(value));
+}
+function isAncestor(parent, child) {
+  const normalizedParent = pathUtils.normalizePathForComparison(parent).replace(/\/$/, "");
+  const normalizedChild = pathUtils.normalizePathForComparison(child);
+  return normalizedChild === normalizedParent || normalizedChild.startsWith(`${normalizedParent}/`);
+}
+function resolveGroupRoot(dirs, serverRoot) {
+  if (!dirs || dirs.length === 0) {
+    return serverRoot ?? process.cwd();
+  }
+  if (serverRoot) {
+    const normalizedRoot = normalizePath(serverRoot);
+    const canUseRoot = dirs.every((dir) => isAncestor(normalizedRoot, dir));
+    if (canUseRoot) {
+      return normalizedRoot;
+    }
+  }
+  if (dirs.length === 1) {
+    return normalizePath(pathe.dirname(dirs[0]));
+  }
+  let common = normalizePath(dirs[0]);
+  for (const dir of dirs.slice(1)) {
+    const normalizedDir = normalizePath(dir);
+    while (common && !isAncestor(common, normalizedDir)) {
+      const parent = normalizePath(pathe.dirname(common));
+      if (parent === common) {
+        break;
+      }
+      common = parent;
+    }
+  }
+  if (!common || common === "/") {
+    return serverRoot ?? process.cwd();
+  }
+  return common;
+}
+function resolveGroups(dirs, root) {
+  const groups = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const dir of dirs) {
+    const normalized = normalizePath(dir);
+    const compareKey = pathUtils.normalizePathForComparison(dir);
+    if (seen.has(compareKey)) {
+      continue;
+    }
+    seen.add(compareKey);
+    const rel = pathUtils.toPosix(pathe.relative(root, normalized));
+    const label = rel && !rel.startsWith("..") ? rel : normalized;
+    groups.push({
+      key: normalized,
+      label,
+      path: normalized
+    });
+  }
+  return groups;
+}
+function resolveRouteGroup(routeFile, groups) {
+  if (groups.length === 0) {
+    return void 0;
+  }
+  const normalizedFile = pathUtils.normalizePathForComparison(routeFile);
+  let matched;
+  for (const group of groups) {
+    const normalizedGroup = pathUtils.normalizePathForComparison(group.path);
+    if (normalizedFile === normalizedGroup || normalizedFile.startsWith(`${normalizedGroup}/`)) {
+      if (!matched || group.path.length > matched.path.length) {
+        matched = group;
+      }
+    }
+  }
+  return matched;
+}
+function formatRouteFile(file, root) {
+  if (!root) {
+    return pathUtils.toPosix(file);
+  }
+  const rel = pathUtils.toPosix(pathe.relative(root, file));
+  if (!rel || rel.startsWith("..")) {
+    return pathUtils.toPosix(file);
+  }
+  return rel;
+}
+
+exports.formatRouteFile = formatRouteFile;
+exports.resolveGroupRoot = resolveGroupRoot;
+exports.resolveGroups = resolveGroups;
+exports.resolveRouteGroup = resolveRouteGroup;

package/dist/playground-grouping.d.cts

@@ -0,0 +1,12 @@
+interface PlaygroundGroup {
+    key: string;
+    label: string;
+    path: string;
+}
+declare function resolveGroupRoot(dirs: string[], serverRoot?: string): string;
+declare function resolveGroups(dirs: string[], root: string): PlaygroundGroup[];
+declare function resolveRouteGroup(routeFile: string, groups: PlaygroundGroup[]): PlaygroundGroup | undefined;
+declare function formatRouteFile(file: string, root?: string): string;
+
+export { formatRouteFile, resolveGroupRoot, resolveGroups, resolveRouteGroup };
+export type { PlaygroundGroup };

package/dist/playground-grouping.d.mts

@@ -0,0 +1,12 @@
+interface PlaygroundGroup {
+    key: string;
+    label: string;
+    path: string;
+}
+declare function resolveGroupRoot(dirs: string[], serverRoot?: string): string;
+declare function resolveGroups(dirs: string[], root: string): PlaygroundGroup[];
+declare function resolveRouteGroup(routeFile: string, groups: PlaygroundGroup[]): PlaygroundGroup | undefined;
+declare function formatRouteFile(file: string, root?: string): string;
+
+export { formatRouteFile, resolveGroupRoot, resolveGroups, resolveRouteGroup };
+export type { PlaygroundGroup };

package/dist/playground-grouping.d.ts

@@ -0,0 +1,12 @@
+interface PlaygroundGroup {
+    key: string;
+    label: string;
+    path: string;
+}
+declare function resolveGroupRoot(dirs: string[], serverRoot?: string): string;
+declare function resolveGroups(dirs: string[], root: string): PlaygroundGroup[];
+declare function resolveRouteGroup(routeFile: string, groups: PlaygroundGroup[]): PlaygroundGroup | undefined;
+declare function formatRouteFile(file: string, root?: string): string;
+
+export { formatRouteFile, resolveGroupRoot, resolveGroups, resolveRouteGroup };
+export type { PlaygroundGroup };

package/dist/playground-grouping.mjs

@@ -0,0 +1,90 @@
+import { cwd } from 'node:process';
+import { relative, dirname, normalize } from 'pathe';
+import { toPosix, normalizePathForComparison } from './path-utils.mjs';
+
+function normalizePath(value) {
+  return normalize(toPosix(value));
+}
+function isAncestor(parent, child) {
+  const normalizedParent = normalizePathForComparison(parent).replace(/\/$/, "");
+  const normalizedChild = normalizePathForComparison(child);
+  return normalizedChild === normalizedParent || normalizedChild.startsWith(`${normalizedParent}/`);
+}
+function resolveGroupRoot(dirs, serverRoot) {
+  if (!dirs || dirs.length === 0) {
+    return serverRoot ?? cwd();
+  }
+  if (serverRoot) {
+    const normalizedRoot = normalizePath(serverRoot);
+    const canUseRoot = dirs.every((dir) => isAncestor(normalizedRoot, dir));
+    if (canUseRoot) {
+      return normalizedRoot;
+    }
+  }
+  if (dirs.length === 1) {
+    return normalizePath(dirname(dirs[0]));
+  }
+  let common = normalizePath(dirs[0]);
+  for (const dir of dirs.slice(1)) {
+    const normalizedDir = normalizePath(dir);
+    while (common && !isAncestor(common, normalizedDir)) {
+      const parent = normalizePath(dirname(common));
+      if (parent === common) {
+        break;
+      }
+      common = parent;
+    }
+  }
+  if (!common || common === "/") {
+    return serverRoot ?? cwd();
+  }
+  return common;
+}
+function resolveGroups(dirs, root) {
+  const groups = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const dir of dirs) {
+    const normalized = normalizePath(dir);
+    const compareKey = normalizePathForComparison(dir);
+    if (seen.has(compareKey)) {
+      continue;
+    }
+    seen.add(compareKey);
+    const rel = toPosix(relative(root, normalized));
+    const label = rel && !rel.startsWith("..") ? rel : normalized;
+    groups.push({
+      key: normalized,
+      label,
+      path: normalized
+    });
+  }
+  return groups;
+}
+function resolveRouteGroup(routeFile, groups) {
+  if (groups.length === 0) {
+    return void 0;
+  }
+  const normalizedFile = normalizePathForComparison(routeFile);
+  let matched;
+  for (const group of groups) {
+    const normalizedGroup = normalizePathForComparison(group.path);
+    if (normalizedFile === normalizedGroup || normalizedFile.startsWith(`${normalizedGroup}/`)) {
+      if (!matched || group.path.length > matched.path.length) {
+        matched = group;
+      }
+    }
+  }
+  return matched;
+}
+function formatRouteFile(file, root) {
+  if (!root) {
+    return toPosix(file);
+  }
+  const rel = toPosix(relative(root, file));
+  if (!rel || rel.startsWith("..")) {
+    return toPosix(file);
+  }
+  return rel;
+}
+
+export { formatRouteFile, resolveGroupRoot, resolveGroups, resolveRouteGroup };

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;