@sourceregistry/sveltekit-enhance 1.0.0

package/dist/helpers/form.js

@@ -0,0 +1,530 @@
+import { fail } from "../index.js";
+const reviveMap = new Map([
+    ['true', () => true],
+    ['false', () => false],
+    ['null', () => null],
+    ['undefined', () => undefined],
+    ['Infinity', () => Infinity],
+    ['-Infinity', () => -Infinity],
+    ['NaN', () => NaN],
+    [/^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/, (v) => Number(v)],
+    [/^\s*\{[\s\S]*}\s*$/, (v) => JSON.parse(v, reviver)],
+    [/^\s*\[[\s\S]*]\s*$/, (v) => JSON.parse(v, reviver)]
+]);
+export const reviver = (key, value) => {
+    if (typeof value !== 'string')
+        return value;
+    for (const [pattern, converter] of reviveMap) {
+        if ((typeof pattern === 'string' && pattern === value) ||
+            (pattern instanceof RegExp && pattern.test(value))) {
+            try {
+                return converter(value);
+            }
+            catch {
+                return value;
+            }
+        }
+    }
+    return value;
+};
+const createContext = (data) => {
+    return {
+        get data() {
+            return data;
+        },
+        has: (...names) => {
+            if (names.length === 0)
+                return false;
+            if (names.length === 1)
+                return data.has(names[0]);
+            else
+                return hasOneOf(data, names);
+        },
+        hasOneOf: (...name) => hasOneOf(data, name),
+        string: (name) => string(data, name) ?? undefined,
+        _string: (name) => string(data, name),
+        string$: (name) => string$(data, name),
+        pattern$: (name, pattern) => pattern$(data, name, pattern),
+        enum: (name, _enum) => Enum(data, name, _enum),
+        enum$: (name, _enum) => Enum$(data, name, _enum),
+        date: (name, parser = (data, name) => data.get(name)) => date(data, name, parser),
+        date$: (name, parser = (data, name) => data.get(name)) => date$(data, name, parser),
+        process: (name, parser, processor) => process(data, name, (formdata, name) => parser.length === 2
+            ? parser(formdata, name)
+            : parser(name), processor),
+        number: (name) => number(data, name),
+        number$: (name) => number$(data, name),
+        boolean: (name) => boolean(data, name),
+        boolean$: (name) => boolean$(data, name),
+        json: (name, transformer = (val) => val) => json(data, name, transformer),
+        jsond: (options) => jsond(data, options),
+        json$: (name, transformer = (val) => val) => json$(data, name, transformer),
+        file: (name) => file(data, name),
+        file$: (name) => file$(data, name),
+        files: (name) => files(data, name),
+        fileRecord: (prefix, removePrefix = false) => fileRecord(data, prefix, removePrefix),
+        array: (name, mapper) => array(data, name, mapper),
+        array$: (name, mapper) => array$(data, name, mapper),
+        onlyIf: (condition, TRUE, FALSE = undefined) => onlyIf(condition, TRUE, FALSE),
+        onlyIfPresent: (key, TRUE, FALSE = undefined) => onlyIfPresent(data, key, TRUE, FALSE),
+        onlyIfArrayPresent: (key, TRUE, FALSE) => onlyIfArrayPresent(data, key, TRUE, FALSE),
+        selector: (cases, useArray = false) => selector(data, cases, useArray),
+        selector$: (cases, useArray = false) => selector$(data, cases, useArray),
+        basedOn: (val, processor = (val) => val) => basedOn(val, processor),
+        record: (options) => record(data, options),
+        validate: (schema, options = {
+            unpack_prefixed: true,
+            transform: (value) => value
+        }) => validate(data, schema, options)
+    };
+};
+export function hasOneOf(formdata, names) {
+    return names.some((name) => formdata.has(name));
+}
+export function string(formdata, name) {
+    if (!formdata.has(name)) {
+        return undefined;
+    }
+    const data = formdata.get(name);
+    if (data === 'null' || data === null)
+        return null;
+    if (typeof data != 'string') {
+        fail(400, { targets: [name], message: `${name} isn't of type string` });
+    }
+    return data;
+}
+export function string$(formdata, name) {
+    if (!formdata.has(name)) {
+        fail(400, { targets: [name], message: `${name} is required` });
+    }
+    const data = formdata.get(name);
+    if (typeof data != 'string') {
+        fail(400, { targets: [name], message: `${name} is not correct data type` });
+    }
+    return data;
+}
+/**
+ * Reads a required string and validates it against a regex pattern.
+ * Accepts either a prebuilt `RegExp` or a pattern string.
+ * Throws a SvelteKit `fail(400)` callback when required checks fail.
+ */
+export function pattern$(formdata, name, pattern) {
+    if (!formdata.has(name))
+        fail(400, { targets: [name], message: `${name} is required` });
+    const data = formdata.get(name);
+    if (!data || typeof data != 'string')
+        return fail(400, { targets: [name], message: `${name} is not correct data type` });
+    if (typeof pattern === 'string')
+        pattern = new RegExp(pattern);
+    if (!pattern.test(data.toString()))
+        fail(400, { targets: [name], message: `${name} is not in correct format` });
+    return data;
+}
+export function number(formdata, name) {
+    if (!formdata.has(name)) {
+        return undefined;
+    }
+    const num = Number(formdata.get(name));
+    if (isNaN(num)) {
+        fail(400, { targets: [name], message: `${name} isn't of type number` });
+    }
+    return num;
+}
+export function number$(formdata, name) {
+    const _number = number(formdata, name);
+    if (_number === undefined) {
+        fail(400, { targets: [name], message: `${name} is required` });
+    }
+    return _number;
+}
+export function boolean(formdata, name) {
+    if (!formdata.has(name)) {
+        return undefined;
+    }
+    const data = formdata.get(name);
+    const num = Number(data);
+    if (!isNaN(num)) {
+        return num > 0;
+    }
+    else {
+        return data.trim().toLowerCase().startsWith('t') || data.trim().toLowerCase() === 'on';
+    }
+}
+export function boolean$(formdata, name) {
+    if (!formdata.has(name)) {
+        fail(400, { targets: [name], message: `${name} is required` });
+    }
+    const data = formdata.get(name);
+    const num = Number(data);
+    if (!isNaN(num)) {
+        return num > 0;
+    }
+    else {
+        return data.trim().toLowerCase().startsWith('t') || data.trim().toLowerCase() === 'on';
+    }
+}
+export function date(formdata, name, parser = (data, name) => data.get(name)) {
+    if (!formdata.has(name)) {
+        return undefined;
+    }
+    const val = parser(formdata, name);
+    if (!val) {
+        return undefined;
+    }
+    return new Date(val);
+}
+export function date$(formdata, name, parser) {
+    return new Date(parser(formdata, name));
+}
+export function json(formdata, name, transformer = (val) => val) {
+    if (!formdata.has(name)) {
+        return undefined;
+    }
+    try {
+        return transformer(JSON.parse(formdata.get(name), reviver));
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    }
+    catch (e) {
+        fail(400, { targets: [name], message: `${name} isn't of json` });
+    }
+}
+export function record(formdata, options) {
+    return Object.fromEntries(formdata
+        .keys()
+        .map((key) => {
+        let entry = [key, formdata.getAll(key)];
+        if (options && options.filter && !options.filter(entry))
+            return;
+        return entry;
+    })
+        .filter((v) => v !== undefined)
+        .map(([key, value]) => [key, Array.isArray(value) && value.length === 1 ? value[0] : value])
+        .map((entry) => {
+        if (options && options.transformer)
+            entry = options.transformer(entry);
+        return entry;
+    }));
+}
+export function json$(formdata, name, transformer = (val) => val) {
+    if (!formdata.has(name)) {
+        fail(400, { targets: [name], message: `${name} doesn't exist` });
+    }
+    try {
+        return transformer(JSON.parse(formdata.get(name), reviver));
+    }
+    catch (e) {
+        throw () => fail(400, {
+            targets: [name],
+            message: `${name} isn't of type json`,
+            error: e instanceof Error ? e?.message : e?.toString()
+        });
+    }
+}
+export function jsond(formdata, options = {
+    unpack_prefixed: true,
+    transform: (value) => value
+}) {
+    let result = {};
+    formdata
+        .entries()
+        .filter(([key]) => (options.prefix_name ? key.startsWith(options.prefix_name) : key))
+        .map(([key, value]) => [key, (options.transform ?? ((value) => value))(value, key, formdata)])
+        .map(([key, value]) => (options.unpack_prefixed && options.prefix_name
+        ? [key.replace(options.prefix_name, ''), value]
+        : [key, value]))
+        .forEach(([key, value]) => {
+        const splits = key.split('.');
+        let context = result;
+        splits.forEach((part, index) => {
+            if (index === splits.length - 1) {
+                // If it's the last part, check if the key already exists
+                if (context[part] === undefined) {
+                    context[part] = value;
+                }
+                else if (Array.isArray(context[part])) {
+                    context[part].push(value);
+                }
+                else {
+                    context[part] = [context[part], value];
+                }
+            }
+            else {
+                // If the key doesn't exist, initialize it as an object
+                if (!context[part])
+                    context[part] = {};
+                // Move deeper into the object
+                context = context[part];
+            }
+        });
+    });
+    if (options.processor) {
+        result = options.processor(result);
+    }
+    return result;
+}
+export function file(formdata, name) {
+    if (!formdata.has(name)) {
+        return undefined;
+    }
+    const data = formdata.get(name);
+    if (data instanceof File) {
+        return formdata.get(name);
+    }
+    else if (data === null || data === 'null') {
+        return null;
+    }
+    fail(400, { targets: [name], message: `${name} isn't of type File` });
+}
+export function fileRecord(formdata, prefix, removePrefix = false) {
+    const record = {};
+    formdata
+        .entries()
+        .filter(([key, value]) => key.startsWith(prefix) && value instanceof File && value.size > 0 && value.name.length > 0)
+        .map(([key, value]) => [removePrefix ? key.replace(prefix, '') : key, value])
+        .forEach(([key, value]) => {
+        if (!(key in record) || !record[key])
+            return (record[key] = [value]);
+        else
+            record[key].push(value);
+    });
+    return record;
+}
+export function file$(formdata, name) {
+    if (!formdata.has(name)) {
+        fail(400, { targets: [name], message: `${name} doesn't exist` });
+    }
+    const data = formdata.get(name);
+    if (data instanceof File) {
+        return formdata.get(name);
+    }
+    fail(400, { targets: [name], message: `${name} isn't of type File` });
+}
+export function files(formdata, name) {
+    if (!formdata.has(name)) {
+        return [];
+    }
+    return (formdata.getAll(name).filter((e) => e instanceof File && e.size > 0 && e.name.length > 0));
+}
+export function array(formdata, name, mapper) {
+    if (!formdata.has(name)) {
+        return undefined;
+    }
+    const array = formdata.getAll(name);
+    if (array.length === 1 && array[0] === '[]') {
+        return [];
+    }
+    if (!mapper) {
+        return array;
+    }
+    return array.map(mapper);
+}
+export function array$(formdata, name, mapper) {
+    if (!formdata.has(name)) {
+        fail(400, { targets: [name], message: `${name} doesn't exist` });
+    }
+    const array = formdata.getAll(name);
+    if (!mapper) {
+        return array;
+    }
+    const res = array.map(mapper);
+    if (res.length === 0) {
+        fail(400, { targets: [name], message: `${name} length of array === 0` });
+    }
+    return res;
+}
+/**
+ * TODO not compliant with enum standard but works for now
+ * @param formdata
+ * @param name
+ * @param _enum
+ */
+export function Enum(formdata, name, _enum) {
+    if (!formdata.has(name)) {
+        return undefined;
+    }
+    const data = formdata.get(name);
+    if (typeof data != 'string') {
+        return fail(400, { targets: [name], message: `${name} isn't of type in enum` });
+    }
+    if (!(data in _enum))
+        return undefined;
+    return data;
+}
+/**
+ * TODO not compliant with enum standard but works for now
+ * @param formdata
+ * @param name
+ * @param _enum
+ */
+export function Enum$(formdata, name, _enum) {
+    const data = Enum(formdata, name, _enum);
+    if (!data)
+        return fail(400, { targets: [name], message: `${name} isn't of type in enum` });
+    return _enum[data];
+}
+export function OldArray(formdata, name, parser) {
+    const data = string(formdata, name);
+    if (!data) {
+        return [];
+    }
+    return parser({ data });
+}
+export function arrayString(formdata, name, delimiter, mapper) {
+    return OldArray(formdata, name, ({ data }) => data.split(delimiter).map(mapper ?? ((i) => i)));
+}
+export function onlyIf(condition, TRUE, FALSE = undefined) {
+    return condition ? TRUE : FALSE;
+}
+export function onlyIfPresent(formdata, key, TRUE, FALSE = undefined) {
+    return formdata.has(key) ? TRUE(formdata.get(key)) : FALSE;
+}
+export function onlyIfArrayPresent(formdata, key, TRUE, FALSE) {
+    return formdata.has(key) && Array.isArray(formdata.getAll(key))
+        ? TRUE(formdata.getAll(key))
+        : FALSE;
+}
+export function basedOn(val, processor = (val) => val) {
+    return processor(val);
+}
+export function selector(formData, cases, useArray = false) {
+    try {
+        for (const key of formData.keys()) {
+            if (key in cases) {
+                const processor = cases[key];
+                if (formData.has(key)) {
+                    if (useArray) {
+                        const data = formData.getAll(key);
+                        if (data.length > 0) {
+                            return processor(data, key);
+                        }
+                    }
+                    else {
+                        const data = formData.get(key);
+                        if (data !== null) {
+                            return processor(data, key);
+                        }
+                    }
+                }
+            }
+        }
+        if ('$default' in cases) {
+            return cases.$default(formData);
+        }
+    }
+    catch (error) {
+        // Call $error in case of any error
+        if ('$error' in cases) {
+            return cases.$error?.(error);
+        }
+    }
+    return undefined;
+}
+export function selector$(formData, cases, useArray = false) {
+    const result = selector(formData, cases, useArray);
+    if (!result) {
+        if ('$error' in cases) {
+            cases?.['$error']?.('Unable to find value');
+        }
+        fail(400, { targets: Object.keys(cases), message: `Unable to find value` });
+    }
+    return result;
+}
+export async function handle(data, fn, ...errorHandlers) {
+    try {
+        if (data instanceof Request &&
+            data.headers.has('Content-Type') &&
+            data.headers.get('Content-Type')?.includes('form')) {
+            data = await data.formData();
+        }
+        else {
+            return fail(400, { message: "Request doesn't contain form data" });
+        }
+        return await fn({ data: data, form: createContext(data) });
+    }
+    catch (e) {
+        for (const errorHandler of errorHandlers) {
+            try {
+                await errorHandler(e);
+            }
+            catch (e) {
+                throw e;
+            }
+        }
+        throw e;
+    }
+}
+export async function enhance(input) {
+    const data = input.request.headers.has('Content-Type') &&
+        input.request.headers.get('Content-Type')?.includes('form')
+        ? await input.request.formData()
+        : new FormData();
+    return {
+        form: createContext(data)
+    };
+}
+export function process(formdata, name, parser, processor) {
+    return processor(parser(formdata, name), name);
+}
+export function validate(formdata, validator, options = {
+    unpack_prefixed: true,
+    transform: (value) => {
+        if (value instanceof File)
+            return value;
+        else
+            return reviver(undefined, value);
+    }
+}) {
+    let value = jsond(formdata, {
+        unpack_prefixed: true,
+        ...options,
+        transform: (v) => reviver(undefined, v),
+    });
+    const result = validator(value);
+    if (!result.success) {
+        return fail(400, {
+            message: "Missing or invalid form data",
+            targets: [result.errors.map(({ path }) => path.replace('$.', options.prefix_name || ''))]
+        });
+    }
+    return result.data;
+}
+export const schema = (validator, options = {
+    unpack_prefixed: true,
+    transform: (value) => value
+}) => async (input) => {
+    const { form } = await enhance(input);
+    return {
+        form: {
+            ...form,
+            result: form.validate(validator, options)
+        }
+    };
+};
+export const Form = {
+    string,
+    string$,
+    number,
+    number$,
+    boolean,
+    boolean$,
+    date,
+    date$,
+    file,
+    file$,
+    files,
+    array,
+    array$,
+    json,
+    json$,
+    jsond,
+    process,
+    validate,
+    onlyIf,
+    onlyIfPresent,
+    onlyIfArrayPresent,
+    selector,
+    selector$,
+    enhance,
+    schema,
+    handle
+};

package/dist/helpers/index.d.ts

@@ -0,0 +1,5 @@
+export * from './auth.js';
+export * from './devtools.js';
+export * from './featureflag.js';
+export * from './form.ts';
+export * from './request-correlation.ts';

package/dist/helpers/index.js

@@ -0,0 +1,5 @@
+export * from './auth.js';
+export * from './devtools.js';
+export * from './featureflag.js';
+export * from "./form.js";
+export * from "./request-correlation.js";

package/dist/helpers/request-correlation.d.ts

@@ -0,0 +1,9 @@
+import type { EnhanceInput } from "../index.js";
+export type RequestCorrelationLocals = {
+    correlation_id?: string;
+    request_started_at?: string;
+};
+export declare const RequestCorrelation: {
+    header: string;
+    attach: (input: EnhanceInput<"handle">) => void;
+};

package/dist/helpers/request-correlation.js

@@ -0,0 +1,47 @@
+import { randomUUID } from 'node:crypto';
+const CORRELATION_ID_HEADER = 'x-correlation-id';
+const REQUEST_ID_HEADER = 'x-request-id';
+const MAX_CORRELATION_ID_LENGTH = 128;
+const SAFE_CORRELATION_ID_PATTERN = /^[A-Za-z0-9._:-]+$/;
+const normalizeCorrelationId = (raw) => {
+    if (!raw)
+        return undefined;
+    const candidate = raw.trim();
+    if (!candidate)
+        return undefined;
+    if (candidate.length > MAX_CORRELATION_ID_LENGTH)
+        return undefined;
+    if (!SAFE_CORRELATION_ID_PATTERN.test(candidate))
+        return undefined;
+    return candidate;
+};
+const withCorrelationHeader = (response, correlationId) => {
+    try {
+        response.headers.set(CORRELATION_ID_HEADER, correlationId);
+        return response;
+    }
+    catch {
+        const headers = new Headers(response.headers);
+        headers.set(CORRELATION_ID_HEADER, correlationId);
+        return new Response(response.body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers
+        });
+    }
+};
+export const RequestCorrelation = {
+    header: CORRELATION_ID_HEADER,
+    attach: (input) => {
+        const correlationId = normalizeCorrelationId(input.request.headers.get(CORRELATION_ID_HEADER)) ??
+            normalizeCorrelationId(input.request.headers.get(REQUEST_ID_HEADER)) ??
+            randomUUID();
+        if (input.locals) {
+            // @ts-ignore
+            input.locals['correlation_id'] = correlationId;
+            // @ts-ignore
+            input.locals['request_started_at'] = Date.now();
+        }
+        input.responseHandlers.push(({ response }) => withCorrelationHeader(response, correlationId));
+    }
+};

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+import { type Action, type ActionResult, type Cookies, type Handle, type RequestEvent, type ResolveOptions, type ServerLoadEvent } from '@sveltejs/kit';
+import type { RouteId as AppRouteId, LayoutParams as AppLayoutParams } from '$app/types';
+export type MaybePromise<T> = T | Promise<T>;
+export type EnhanceErrorHandler = <T = any>(err: unknown) => MaybePromise<T> | undefined | never | void;
+export type EnhanceResponseHandler = (input: {
+    event: RequestEvent;
+    response: Response;
+}) => MaybePromise<unknown>;
+export type EnhanceCallType = 'handle' | 'load' | 'method' | 'action';
+export type EnhanceInput<CallType extends EnhanceCallType = EnhanceCallType, Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>, RouteId extends AppRouteId | null = AppRouteId | null, ParentData extends Record<string, any> = Record<string, any>> = {
+    cookies: Cookies;
+    params: Params;
+    route: {
+        id: RouteId;
+    };
+    url: URL;
+    locals: App.Locals;
+    request: Request;
+    callType: CallType;
+    fetch: typeof fetch;
+    get errorHandlers(): EnhanceErrorHandler[];
+} & (CallType extends 'handle' ? {
+    get responseHandlers(): EnhanceResponseHandler[];
+    resolve: (event?: RequestEvent) => never;
+    readonly event: RequestEvent;
+} : CallType extends 'load' ? {
+    parent: ServerLoadEvent<Params, ParentData, RouteId>['parent'];
+    depends: ServerLoadEvent<Params, ParentData, RouteId>['depends'];
+    untrack: ServerLoadEvent<Params, ParentData, RouteId>['untrack'];
+} : object);
+export type EnhanceFunction<CallType extends EnhanceCallType = EnhanceCallType, Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>, RouteId extends AppRouteId | null = AppRouteId | null, EnhanceReturn = any> = (event: EnhanceInput<CallType, Params, RouteId>) => MaybePromise<EnhanceReturn>;
+export type EnhanceAction<Params extends AppLayoutParams<'/'>, OutputData extends Record<string, any> | void, RouteId extends AppRouteId | null, EnhanceReturn extends ActionResult | never | any = ActionResult> = (event: RequestEvent<Params, RouteId> & {
+    context: EnhanceReturn;
+}) => MaybePromise<OutputData>;
+export type EnhanceLoad<Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>, ParentData extends Record<string, any> = Record<string, any>, OutputData extends Record<string, any> | void = Record<string, any> | void, RouteId extends AppRouteId | null = AppRouteId | null, EnhanceReturn extends never | any = any> = (event: ServerLoadEvent<Params, ParentData, RouteId> & {
+    context: EnhanceReturn;
+}) => MaybePromise<OutputData>;
+export type EnhanceHandle<EnhanceReturn extends never | any = any> = (input: {
+    event: RequestEvent;
+    resolve(event: RequestEvent, opts?: ResolveOptions): MaybePromise<Response>;
+} & {
+    context: EnhanceReturn;
+}) => MaybePromise<Response>;
+export type EnhanceMethod<Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>, RouteId extends AppRouteId | null = AppRouteId | null, EnhanceReturn extends never | any = any> = (event: RequestEvent<Params, RouteId> & {
+    context: EnhanceReturn;
+}) => MaybePromise<Response>;
+export declare const action: <Params extends AppLayoutParams<"/"> = AppLayoutParams<"/">, OutputData extends Record<string, any> | void = Record<string, any> | void, RouteId extends AppRouteId | null = AppRouteId | null, const Enhances extends readonly EnhanceFunction<"action", Params, RouteId, object>[] = readonly EnhanceFunction<"action", Params, RouteId, object>[], EnhanceReturn extends ConcatReturnTypes<Enhances> = ConcatReturnTypes<Enhances>>(action: EnhanceAction<Params, OutputData, RouteId, EnhanceReturn>, ...enhances: [...Enhances]) => Action<Params, OutputData, RouteId>;
+export declare const load: <Params extends AppLayoutParams<"/"> = AppLayoutParams<"/">, ParentData extends Record<string, any> = Record<string, any>, OutputData extends Record<string, any> | void = Record<string, any> | void, RouteId extends AppRouteId | null = AppRouteId | null, const Enhances extends readonly EnhanceFunction<"load", Params, RouteId, object>[] = readonly EnhanceFunction<"load", Params, RouteId, object>[], EnhanceReturn extends ConcatReturnTypes<Enhances> = ConcatReturnTypes<Enhances>>(load: EnhanceLoad<Params, ParentData, OutputData, RouteId, EnhanceReturn>, ...contexts: [...Enhances]) => (event: ServerLoadEvent<Params, ParentData, RouteId>) => Promise<OutputData>;
+export declare const method: <Params extends AppLayoutParams<"/"> = AppLayoutParams<"/">, RouteId extends AppRouteId | null = AppRouteId | null, const Enhances extends readonly EnhanceFunction<"method", Params, RouteId, object>[] = readonly EnhanceFunction<"method", Params, RouteId, object>[], EnhanceReturn extends Awaited<ConcatReturnTypes<Enhances>> = Awaited<ConcatReturnTypes<Enhances>>>(handle: EnhanceMethod<Params, RouteId, EnhanceReturn>, ...contexts: [...Enhances]) => (event: RequestEvent<Params, RouteId>) => Promise<Response>;
+export declare const handle: <const Enhances extends readonly EnhanceFunction<"handle">[] = readonly EnhanceFunction<"handle">[], EnhanceReturn extends Awaited<ConcatReturnTypes<Enhances>> = Awaited<ConcatReturnTypes<Enhances>>>(handle: EnhanceHandle<EnhanceReturn>, ...contexts: [...Enhances]) => Handle;
+export declare const enhance: {
+    action: <Params extends AppLayoutParams<"/"> = Record<string, string>, OutputData extends Record<string, any> | void = void | Record<string, any>, RouteId extends AppRouteId | null = string | null, const Enhances extends readonly EnhanceFunction<"action", Params, RouteId, object>[] = readonly EnhanceFunction<"action", Params, RouteId, object>[], EnhanceReturn extends ConcatReturnTypes<Enhances> = ConcatReturnTypes<Enhances>>(action: EnhanceAction<Params, OutputData, RouteId, EnhanceReturn>, ...enhances: Enhances) => Action<Params, OutputData, RouteId>;
+    load: <Params extends AppLayoutParams<"/"> = Record<string, string>, ParentData extends Record<string, any> = Record<string, any>, OutputData extends Record<string, any> | void = void | Record<string, any>, RouteId extends AppRouteId | null = string | null, const Enhances extends readonly EnhanceFunction<"load", Params, RouteId, object>[] = readonly EnhanceFunction<"load", Params, RouteId, object>[], EnhanceReturn extends ConcatReturnTypes<Enhances> = ConcatReturnTypes<Enhances>>(load: EnhanceLoad<Params, ParentData, OutputData, RouteId, EnhanceReturn>, ...contexts: Enhances) => (event: ServerLoadEvent<Params, ParentData, RouteId>) => Promise<OutputData>;
+    method: <Params extends AppLayoutParams<"/"> = Record<string, string>, RouteId extends AppRouteId | null = string | null, const Enhances extends readonly EnhanceFunction<"method", Params, RouteId, object>[] = readonly EnhanceFunction<"method", Params, RouteId, object>[], EnhanceReturn extends Awaited<ConcatReturnTypes<Enhances>> = Awaited<ConcatReturnTypes<Enhances>>>(handle: EnhanceMethod<Params, RouteId, EnhanceReturn>, ...contexts: Enhances) => (event: RequestEvent<Params, RouteId>) => Promise<Response>;
+    handle: <const Enhances extends readonly EnhanceFunction<"handle">[] = readonly EnhanceFunction<"handle", Record<string, string>, string | null, any>[], EnhanceReturn extends Awaited<ConcatReturnTypes<Enhances>> = Awaited<ConcatReturnTypes<Enhances>>>(handle: EnhanceHandle<EnhanceReturn>, ...contexts: Enhances) => Handle;
+};
+export type Enhancers<Params extends AppLayoutParams<'/'> = AppLayoutParams<'/'>, RouteId extends AppRouteId | null = AppRouteId | null, EnhanceReturn extends never | any = any> = Record<string, EnhanceFunction<EnhanceCallType, Params, RouteId, EnhanceReturn>>;
+export type Func = (...args: any[]) => any;
+export type ConcatReturnTypes<T extends readonly Func[]> = T extends readonly [] ? Record<never, never> : T extends readonly [infer First, ...infer Rest] ? First extends Func ? Awaited<ReturnType<First>> & ConcatReturnTypes<Rest extends readonly Func[] ? Rest : []> : Record<never, never> : Record<never, never>;
+export declare const fail: <T extends Record<string, unknown> | undefined = undefined>(status: number, data: T) => never;
+export declare const error: (status: number, body?: {
+    message: string;
+} extends App.Error ? App.Error | string | undefined : never) => never;
+export declare const success: <T extends Record<string, unknown> | undefined = undefined>(data: T) => T;
+export declare function not_good(input: {
+    callType: EnhanceInput['callType'];
+}, status: number, arg?: App.Error | string | Record<string, unknown> | undefined): never;
+export * from './helpers/index.js';