@mokup/shared 1.1.0 → 1.1.2

package/dist/config-core.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+const middlewareSymbol = Symbol.for("mokup.config.middlewares");
+function isPromise(value) {
+  return !!value && typeof value.then === "function";
+}
+
+exports.isPromise = isPromise;
+exports.middlewareSymbol = middlewareSymbol;

package/dist/config-core.d.cts

@@ -0,0 +1,4 @@
+declare const middlewareSymbol: unique symbol;
+declare function isPromise<T = unknown>(value: T | Promise<T>): value is Promise<T>;
+
+export { isPromise, middlewareSymbol };

package/dist/config-core.d.mts

@@ -0,0 +1,4 @@
+declare const middlewareSymbol: unique symbol;
+declare function isPromise<T = unknown>(value: T | Promise<T>): value is Promise<T>;
+
+export { isPromise, middlewareSymbol };

package/dist/config-core.d.ts

@@ -0,0 +1,4 @@
+declare const middlewareSymbol: unique symbol;
+declare function isPromise<T = unknown>(value: T | Promise<T>): value is Promise<T>;
+
+export { isPromise, middlewareSymbol };

package/dist/config-core.mjs

@@ -0,0 +1,6 @@
+const middlewareSymbol = Symbol.for("mokup.config.middlewares");
+function isPromise(value) {
+  return !!value && typeof value.then === "function";
+}
+
+export { isPromise, middlewareSymbol };

package/dist/config-utils.cjs

@@ -0,0 +1,179 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const configCore = require('./config-core.cjs');
+const pathe = require('pathe');
+
+function readMiddlewareMeta(config) {
+  const value = config[configCore.middlewareSymbol];
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const meta = value;
+  return {
+    pre: Array.isArray(meta.pre) ? meta.pre : [],
+    normal: Array.isArray(meta.normal) ? meta.normal : [],
+    post: Array.isArray(meta.post) ? meta.post : []
+  };
+}
+function normalizeMiddlewareList(params) {
+  const { value, source, position, warn, map } = params;
+  if (!value) {
+    return [];
+  }
+  const list = Array.isArray(value) ? value : [value];
+  const middlewares = [];
+  list.forEach((entry, index) => {
+    if (typeof entry !== "function") {
+      warn?.(`Invalid middleware in ${source}`);
+      return;
+    }
+    middlewares.push(map(entry, index, position));
+  });
+  return middlewares;
+}
+function buildConfigChain(file, rootDir) {
+  const resolvedRoot = pathe.normalize(rootDir);
+  const resolvedFileDir = pathe.normalize(pathe.dirname(file));
+  const chain = [];
+  let current = resolvedFileDir;
+  while (true) {
+    chain.push(current);
+    if (current === resolvedRoot) {
+      break;
+    }
+    const parent = pathe.dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  chain.reverse();
+  return chain;
+}
+function getConfigFileCandidates(dir, extensions) {
+  return extensions.map((extension) => pathe.join(dir, `index.config${extension}`));
+}
+async function findConfigFile(dir, cache, extensions) {
+  const cached = cache.get(dir);
+  if (cached !== void 0) {
+    return cached;
+  }
+  for (const candidate of getConfigFileCandidates(dir, extensions)) {
+    try {
+      await node_fs.promises.stat(candidate);
+      cache.set(dir, candidate);
+      return candidate;
+    } catch {
+      continue;
+    }
+  }
+  cache.set(dir, null);
+  return null;
+}
+async function resolveDirectoryConfig(params) {
+  const { file, rootDir, configExtensions, configCache, fileCache, loadConfig, warn, mapMiddleware } = params;
+  const chain = buildConfigChain(file, rootDir);
+  const merged = {};
+  const preMiddlewares = [];
+  const normalMiddlewares = [];
+  const postMiddlewares = [];
+  const configChain = [];
+  const configSources = {};
+  for (const dir of chain) {
+    const configPath = await findConfigFile(dir, fileCache, configExtensions);
+    if (!configPath) {
+      continue;
+    }
+    let config = configCache.get(configPath);
+    if (config === void 0) {
+      config = await loadConfig(configPath);
+      configCache.set(configPath, config);
+    }
+    if (!config) {
+      warn?.(`Invalid config in ${configPath}`);
+      continue;
+    }
+    configChain.push(configPath);
+    if (config.headers) {
+      merged.headers = { ...merged.headers ?? {}, ...config.headers };
+      configSources.headers = configPath;
+    }
+    if (typeof config.status === "number") {
+      merged.status = config.status;
+      configSources.status = configPath;
+    }
+    if (typeof config.delay === "number") {
+      merged.delay = config.delay;
+      configSources.delay = configPath;
+    }
+    if (typeof config.enabled === "boolean") {
+      merged.enabled = config.enabled;
+      configSources.enabled = configPath;
+    }
+    if (typeof config.ignorePrefix !== "undefined") {
+      merged.ignorePrefix = config.ignorePrefix;
+      configSources.ignorePrefix = configPath;
+    }
+    if (typeof config.include !== "undefined") {
+      merged.include = config.include;
+      configSources.include = configPath;
+    }
+    if (typeof config.exclude !== "undefined") {
+      merged.exclude = config.exclude;
+      configSources.exclude = configPath;
+    }
+    const meta = readMiddlewareMeta(config);
+    preMiddlewares.push(
+      ...normalizeMiddlewareList({
+        value: meta?.pre,
+        source: configPath,
+        position: "pre",
+        warn,
+        map: (handler, index, position) => mapMiddleware(handler, index, position, configPath)
+      })
+    );
+    normalMiddlewares.push(
+      ...normalizeMiddlewareList({
+        value: meta?.normal,
+        source: configPath,
+        position: "normal",
+        warn,
+        map: (handler, index, position) => mapMiddleware(handler, index, position, configPath)
+      })
+    );
+    normalMiddlewares.push(
+      ...normalizeMiddlewareList({
+        value: config.middleware,
+        source: configPath,
+        position: "normal",
+        warn,
+        map: (handler, index, position) => mapMiddleware(handler, index, position, configPath)
+      })
+    );
+    postMiddlewares.push(
+      ...normalizeMiddlewareList({
+        value: meta?.post,
+        source: configPath,
+        position: "post",
+        warn,
+        map: (handler, index, position) => mapMiddleware(handler, index, position, configPath)
+      })
+    );
+  }
+  return {
+    ...merged,
+    middlewares: [...preMiddlewares, ...normalMiddlewares, ...postMiddlewares],
+    configChain,
+    configSources
+  };
+}
+
+exports.isPromise = configCore.isPromise;
+exports.middlewareSymbol = configCore.middlewareSymbol;
+exports.buildConfigChain = buildConfigChain;
+exports.findConfigFile = findConfigFile;
+exports.getConfigFileCandidates = getConfigFileCandidates;
+exports.normalizeMiddlewareList = normalizeMiddlewareList;
+exports.readMiddlewareMeta = readMiddlewareMeta;
+exports.resolveDirectoryConfig = resolveDirectoryConfig;

package/dist/config-utils.d.cts

@@ -0,0 +1,62 @@
+export { isPromise, middlewareSymbol } from './config-core.cjs';
+
+type MiddlewarePosition = 'pre' | 'normal' | 'post';
+interface MiddlewareMeta {
+    pre?: unknown[];
+    normal?: unknown[];
+    post?: unknown[];
+}
+interface ConfigSourceMap {
+    headers?: string;
+    status?: string;
+    delay?: string;
+    enabled?: string;
+    ignorePrefix?: string;
+    include?: string;
+    exclude?: string;
+}
+declare function readMiddlewareMeta(config: Record<symbol, unknown>): MiddlewareMeta | null;
+
+declare function normalizeMiddlewareList<T>(params: {
+    value: unknown;
+    source: string;
+    position: MiddlewarePosition;
+    warn?: (message: string) => void;
+    map: (handler: (...args: unknown[]) => unknown, index: number, position: MiddlewarePosition) => T;
+}): T[];
+declare function buildConfigChain(file: string, rootDir: string): string[];
+declare function getConfigFileCandidates(dir: string, extensions: readonly string[]): string[];
+declare function findConfigFile(dir: string, cache: Map<string, string | null>, extensions: readonly string[]): Promise<string | null>;
+declare function resolveDirectoryConfig<TConfig extends {
+    headers?: Record<string, string>;
+    status?: number;
+    delay?: number;
+    enabled?: boolean;
+    ignorePrefix?: string | string[];
+    include?: RegExp | RegExp[];
+    exclude?: RegExp | RegExp[];
+    middleware?: unknown;
+}, TMiddleware>(params: {
+    file: string;
+    rootDir: string;
+    configExtensions: readonly string[];
+    configCache: Map<string, TConfig | null>;
+    fileCache: Map<string, string | null>;
+    loadConfig: (file: string) => Promise<TConfig | null>;
+    warn?: (message: string) => void;
+    mapMiddleware: (handler: (...args: unknown[]) => unknown, index: number, position: MiddlewarePosition, source: string) => TMiddleware;
+}): Promise<{
+    middlewares: TMiddleware[];
+    configChain: string[];
+    configSources: ConfigSourceMap;
+    headers?: Record<string, string>;
+    status?: number;
+    delay?: number;
+    enabled?: boolean;
+    ignorePrefix?: string | string[];
+    include?: RegExp | RegExp[];
+    exclude?: RegExp | RegExp[];
+}>;
+
+export { buildConfigChain, findConfigFile, getConfigFileCandidates, normalizeMiddlewareList, readMiddlewareMeta, resolveDirectoryConfig };
+export type { ConfigSourceMap, MiddlewareMeta, MiddlewarePosition };

package/dist/config-utils.d.mts

@@ -0,0 +1,62 @@
+export { isPromise, middlewareSymbol } from './config-core.mjs';
+
+type MiddlewarePosition = 'pre' | 'normal' | 'post';
+interface MiddlewareMeta {
+    pre?: unknown[];
+    normal?: unknown[];
+    post?: unknown[];
+}
+interface ConfigSourceMap {
+    headers?: string;
+    status?: string;
+    delay?: string;
+    enabled?: string;
+    ignorePrefix?: string;
+    include?: string;
+    exclude?: string;
+}
+declare function readMiddlewareMeta(config: Record<symbol, unknown>): MiddlewareMeta | null;
+
+declare function normalizeMiddlewareList<T>(params: {
+    value: unknown;
+    source: string;
+    position: MiddlewarePosition;
+    warn?: (message: string) => void;
+    map: (handler: (...args: unknown[]) => unknown, index: number, position: MiddlewarePosition) => T;
+}): T[];
+declare function buildConfigChain(file: string, rootDir: string): string[];
+declare function getConfigFileCandidates(dir: string, extensions: readonly string[]): string[];
+declare function findConfigFile(dir: string, cache: Map<string, string | null>, extensions: readonly string[]): Promise<string | null>;
+declare function resolveDirectoryConfig<TConfig extends {
+    headers?: Record<string, string>;
+    status?: number;
+    delay?: number;
+    enabled?: boolean;
+    ignorePrefix?: string | string[];
+    include?: RegExp | RegExp[];
+    exclude?: RegExp | RegExp[];
+    middleware?: unknown;
+}, TMiddleware>(params: {
+    file: string;
+    rootDir: string;
+    configExtensions: readonly string[];
+    configCache: Map<string, TConfig | null>;
+    fileCache: Map<string, string | null>;
+    loadConfig: (file: string) => Promise<TConfig | null>;
+    warn?: (message: string) => void;
+    mapMiddleware: (handler: (...args: unknown[]) => unknown, index: number, position: MiddlewarePosition, source: string) => TMiddleware;
+}): Promise<{
+    middlewares: TMiddleware[];
+    configChain: string[];
+    configSources: ConfigSourceMap;
+    headers?: Record<string, string>;
+    status?: number;
+    delay?: number;
+    enabled?: boolean;
+    ignorePrefix?: string | string[];
+    include?: RegExp | RegExp[];
+    exclude?: RegExp | RegExp[];
+}>;
+
+export { buildConfigChain, findConfigFile, getConfigFileCandidates, normalizeMiddlewareList, readMiddlewareMeta, resolveDirectoryConfig };
+export type { ConfigSourceMap, MiddlewareMeta, MiddlewarePosition };

package/dist/config-utils.d.ts

@@ -0,0 +1,62 @@
+export { isPromise, middlewareSymbol } from './config-core.js';
+
+type MiddlewarePosition = 'pre' | 'normal' | 'post';
+interface MiddlewareMeta {
+    pre?: unknown[];
+    normal?: unknown[];
+    post?: unknown[];
+}
+interface ConfigSourceMap {
+    headers?: string;
+    status?: string;
+    delay?: string;
+    enabled?: string;
+    ignorePrefix?: string;
+    include?: string;
+    exclude?: string;
+}
+declare function readMiddlewareMeta(config: Record<symbol, unknown>): MiddlewareMeta | null;
+
+declare function normalizeMiddlewareList<T>(params: {
+    value: unknown;
+    source: string;
+    position: MiddlewarePosition;
+    warn?: (message: string) => void;
+    map: (handler: (...args: unknown[]) => unknown, index: number, position: MiddlewarePosition) => T;
+}): T[];
+declare function buildConfigChain(file: string, rootDir: string): string[];
+declare function getConfigFileCandidates(dir: string, extensions: readonly string[]): string[];
+declare function findConfigFile(dir: string, cache: Map<string, string | null>, extensions: readonly string[]): Promise<string | null>;
+declare function resolveDirectoryConfig<TConfig extends {
+    headers?: Record<string, string>;
+    status?: number;
+    delay?: number;
+    enabled?: boolean;
+    ignorePrefix?: string | string[];
+    include?: RegExp | RegExp[];
+    exclude?: RegExp | RegExp[];
+    middleware?: unknown;
+}, TMiddleware>(params: {
+    file: string;
+    rootDir: string;
+    configExtensions: readonly string[];
+    configCache: Map<string, TConfig | null>;
+    fileCache: Map<string, string | null>;
+    loadConfig: (file: string) => Promise<TConfig | null>;
+    warn?: (message: string) => void;
+    mapMiddleware: (handler: (...args: unknown[]) => unknown, index: number, position: MiddlewarePosition, source: string) => TMiddleware;
+}): Promise<{
+    middlewares: TMiddleware[];
+    configChain: string[];
+    configSources: ConfigSourceMap;
+    headers?: Record<string, string>;
+    status?: number;
+    delay?: number;
+    enabled?: boolean;
+    ignorePrefix?: string | string[];
+    include?: RegExp | RegExp[];
+    exclude?: RegExp | RegExp[];
+}>;
+
+export { buildConfigChain, findConfigFile, getConfigFileCandidates, normalizeMiddlewareList, readMiddlewareMeta, resolveDirectoryConfig };
+export type { ConfigSourceMap, MiddlewareMeta, MiddlewarePosition };

package/dist/config-utils.mjs

@@ -0,0 +1,171 @@
+import { promises } from 'node:fs';
+import { middlewareSymbol } from './config-core.mjs';
+export { isPromise } from './config-core.mjs';
+import { normalize, dirname, join } from 'pathe';
+
+function readMiddlewareMeta(config) {
+  const value = config[middlewareSymbol];
+  if (!value || typeof value !== "object") {
+    return null;
+  }
+  const meta = value;
+  return {
+    pre: Array.isArray(meta.pre) ? meta.pre : [],
+    normal: Array.isArray(meta.normal) ? meta.normal : [],
+    post: Array.isArray(meta.post) ? meta.post : []
+  };
+}
+function normalizeMiddlewareList(params) {
+  const { value, source, position, warn, map } = params;
+  if (!value) {
+    return [];
+  }
+  const list = Array.isArray(value) ? value : [value];
+  const middlewares = [];
+  list.forEach((entry, index) => {
+    if (typeof entry !== "function") {
+      warn?.(`Invalid middleware in ${source}`);
+      return;
+    }
+    middlewares.push(map(entry, index, position));
+  });
+  return middlewares;
+}
+function buildConfigChain(file, rootDir) {
+  const resolvedRoot = normalize(rootDir);
+  const resolvedFileDir = normalize(dirname(file));
+  const chain = [];
+  let current = resolvedFileDir;
+  while (true) {
+    chain.push(current);
+    if (current === resolvedRoot) {
+      break;
+    }
+    const parent = dirname(current);
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  chain.reverse();
+  return chain;
+}
+function getConfigFileCandidates(dir, extensions) {
+  return extensions.map((extension) => join(dir, `index.config${extension}`));
+}
+async function findConfigFile(dir, cache, extensions) {
+  const cached = cache.get(dir);
+  if (cached !== void 0) {
+    return cached;
+  }
+  for (const candidate of getConfigFileCandidates(dir, extensions)) {
+    try {
+      await promises.stat(candidate);
+      cache.set(dir, candidate);
+      return candidate;
+    } catch {
+      continue;
+    }
+  }
+  cache.set(dir, null);
+  return null;
+}
+async function resolveDirectoryConfig(params) {
+  const { file, rootDir, configExtensions, configCache, fileCache, loadConfig, warn, mapMiddleware } = params;
+  const chain = buildConfigChain(file, rootDir);
+  const merged = {};
+  const preMiddlewares = [];
+  const normalMiddlewares = [];
+  const postMiddlewares = [];
+  const configChain = [];
+  const configSources = {};
+  for (const dir of chain) {
+    const configPath = await findConfigFile(dir, fileCache, configExtensions);
+    if (!configPath) {
+      continue;
+    }
+    let config = configCache.get(configPath);
+    if (config === void 0) {
+      config = await loadConfig(configPath);
+      configCache.set(configPath, config);
+    }
+    if (!config) {
+      warn?.(`Invalid config in ${configPath}`);
+      continue;
+    }
+    configChain.push(configPath);
+    if (config.headers) {
+      merged.headers = { ...merged.headers ?? {}, ...config.headers };
+      configSources.headers = configPath;
+    }
+    if (typeof config.status === "number") {
+      merged.status = config.status;
+      configSources.status = configPath;
+    }
+    if (typeof config.delay === "number") {
+      merged.delay = config.delay;
+      configSources.delay = configPath;
+    }
+    if (typeof config.enabled === "boolean") {
+      merged.enabled = config.enabled;
+      configSources.enabled = configPath;
+    }
+    if (typeof config.ignorePrefix !== "undefined") {
+      merged.ignorePrefix = config.ignorePrefix;
+      configSources.ignorePrefix = configPath;
+    }
+    if (typeof config.include !== "undefined") {
+      merged.include = config.include;
+      configSources.include = configPath;
+    }
+    if (typeof config.exclude !== "undefined") {
+      merged.exclude = config.exclude;
+      configSources.exclude = configPath;
+    }
+    const meta = readMiddlewareMeta(config);
+    preMiddlewares.push(
+      ...normalizeMiddlewareList({
+        value: meta?.pre,
+        source: configPath,
+        position: "pre",
+        warn,
+        map: (handler, index, position) => mapMiddleware(handler, index, position, configPath)
+      })
+    );
+    normalMiddlewares.push(
+      ...normalizeMiddlewareList({
+        value: meta?.normal,
+        source: configPath,
+        position: "normal",
+        warn,
+        map: (handler, index, position) => mapMiddleware(handler, index, position, configPath)
+      })
+    );
+    normalMiddlewares.push(
+      ...normalizeMiddlewareList({
+        value: config.middleware,
+        source: configPath,
+        position: "normal",
+        warn,
+        map: (handler, index, position) => mapMiddleware(handler, index, position, configPath)
+      })
+    );
+    postMiddlewares.push(
+      ...normalizeMiddlewareList({
+        value: meta?.post,
+        source: configPath,
+        position: "post",
+        warn,
+        map: (handler, index, position) => mapMiddleware(handler, index, position, configPath)
+      })
+    );
+  }
+  return {
+    ...merged,
+    middlewares: [...preMiddlewares, ...normalMiddlewares, ...postMiddlewares],
+    configChain,
+    configSources
+  };
+}
+
+export { buildConfigChain, findConfigFile, getConfigFileCandidates, middlewareSymbol, normalizeMiddlewareList, readMiddlewareMeta, resolveDirectoryConfig };