kequapp/dist/router/tools/cacher.js

DEPRECATED: renamed to @kequtech/arbor

import path from 'node:path';
import { logger } from "../../built-in/logger.js";
import { errorHandler } from "../handlers/error-handler.js";
import { rendererJson } from "../handlers/renderer-json.js";
import { rendererText } from "../handlers/renderer-text.js";
import { createRegexp } from "./create-regexp.js";
import { priorityContentType, priorityUrl } from "./priority.js";
import { warnDuplicates } from "./warn-duplicates.js";
export function cacheRoutes(structure) {
    const routes = cacheRoutesMeta(structure);
    warnDuplicates(routes, structure.logger?.warn ?? logger.warn);
    return routes.sort(priorityUrl).map((item) => ({
        ...sanitizeBranch(item),
        method: item.method,
    }));
}
function cacheRoutesMeta(target) {
    const routes = [];
    for (const route of target.routes ?? []) {
        routes.push({
            ...extendRoute(target, route),
            method: route.method,
            url: extendUrl(target.url, route.url),
        });
    }
    for (const branch of target.branches ?? []) {
        for (const source of cacheRoutesMeta(branch)) {
            routes.push({
                ...extendBranch(target, source),
                method: source.method,
                url: extendUrl(target.url, source.url),
            });
        }
    }
    return routes;
}
export function cacheBranches(structure) {
    const branches = cacheBranchesMeta(structure);
    branches.push({
        actions: [...(structure.actions ?? [])],
        errorHandlers: [...(structure.errorHandlers ?? [])],
        renderers: [...(structure.renderers ?? [])],
        autoHead: structure.autoHead,
        logger: structure.logger,
        url: '/**',
    });
    return branches.map(sanitizeBranch);
}
function cacheBranchesMeta(target) {
    const branches = [];
    for (const branch of target.branches ?? []) {
        for (const source of cacheBranchesMeta(branch)) {
            branches.push({
                ...extendBranch(target, source),
                url: extendUrl(target.url, source.url),
            });
        }
    }
    return branches;
}
function sanitizeBranch(item) {
    return {
        actions: item.actions,
        regexp: createRegexp(item.url),
        errorHandlers: [...item.errorHandlers.sort(priorityContentType), errorHandler],
        renderers: [...item.renderers.sort(priorityContentType), rendererJson, rendererText],
        autoHead: item.autoHead ?? true,
        logger: item.logger ?? logger,
    };
}
function extendBranch(target, source) {
    return {
        actions: [...(target.actions ?? []), ...source.actions],
        errorHandlers: [...source.errorHandlers, ...(target.errorHandlers ?? [])],
        renderers: [...source.renderers, ...(target.renderers ?? [])],
        autoHead: source.autoHead ?? target.autoHead,
        logger: source.logger ?? target.logger,
    };
}
function extendRoute(target, route) {
    return {
        actions: [...(target.actions ?? []), ...(route.actions ?? [])],
        errorHandlers: [...(target.errorHandlers ?? [])],
        renderers: [...(target.renderers ?? [])],
        autoHead: route.autoHead ?? target.autoHead,
        logger: route.logger ?? target.logger,
    };
}
function extendUrl(target = '/', source = '/') {
    return path.join('/', target, source);
}