@dokebi/template-inertia 0.4.1 → 0.4.4

package/dist/vite-files.d.ts

@@ -0,0 +1,129 @@
+import type { Logger } from '@dokebi/core';
+/**
+ * Files the dev server never serves, whatever the app's config says (Vite globs: a pattern
+ * without `/` matches the name in every folder; letter case is ignored). Vite's own defaults are
+ * included, because a deny list replaces them.
+ */
+export declare const DEV_FILES_DENY: readonly string[];
+/**
+ * Header the app process sets on every request it forwards to the Vite host: `loopback` or
+ * `remote`, from the browser's socket peer, the forwarding headers and the host name it judged
+ * (isRemoteRequest, §12). Any value the browser sent is replaced. Without it (Vite run on its
+ * own) the Vite host judges its own socket, the forwarding headers and the Host header.
+ */
+export declare const DEV_CLIENT_HEADER = "x-dokebi-dev-client";
+/** The whole 403 a remote host gets: no path, no allow list. */
+export declare const FORBIDDEN_SHORT = "403 Forbidden\n";
+/** Whether a host name (no port, no brackets) is this machine: a remote one gets no details. */
+export declare function isLoopbackHost(name: string): boolean;
+/**
+ * Headers a proxy or tunnel adds (D-0129 §12). Any of them makes a request remote: a tunnel
+ * client runs on this machine (its socket is loopback) and may rewrite Host to localhost, so
+ * neither the socket nor the Host header alone tells a local browser from a forwarded one.
+ */
+export declare const FORWARDING_HEADERS: readonly string[];
+/** Whether a socket peer address is this machine (127.0.0.0/8, ::1, ::ffff:127.x). */
+export declare function isLoopbackAddress(address: string | undefined): boolean;
+/**
+ * Whether a request comes from another machine (a `devHosts` tunnel, a proxy, a LAN address).
+ * Local, and so shown details, only when the socket peer is loopback, no forwarding header is
+ * present, the Host is a loopback name and the app process (DEV_CLIENT_HEADER, when set) said
+ * loopback too. An unknown peer counts as remote.
+ */
+export declare function isRemoteRequest(headers: Readonly<Record<string, string | string[] | undefined>>, peer: string | undefined): boolean;
+/**
+ * A Vite deny glob as a regular expression on an absolute `/` path, matched like Vite matches it
+ * (picomatch with `dot` and `nocase`; a pattern without `/` matches in every folder). Supports
+ * `*`, `**`, `?` and `{a,b}`, which is all DEV_FILES_DENY and ordinary app entries use.
+ */
+export declare function denyPattern(glob: string): RegExp;
+/** The part of Vite's resolved config this policy reads (and repairs). */
+export interface ResolvedFilesShape {
+    readonly command: 'build' | 'serve';
+    readonly base: string;
+    readonly root?: string;
+    readonly cacheDir?: string;
+    readonly plugins?: readonly {
+        readonly name?: string;
+    }[];
+    readonly server?: {
+        readonly fs?: {
+            strict: boolean;
+            allow: string[];
+            deny: string[];
+        };
+    };
+    /** Vite's set of files the served modules import (internal, read when present). */
+    readonly safeModulePaths?: ReadonlySet<string>;
+}
+/** The request and response of a connect middleware, as far as the policy needs them. */
+export interface DevRequestShape {
+    url?: string;
+    method?: string;
+    headers?: Record<string, string | string[] | undefined>;
+    /** The socket: its peer address is part of the loopback judgement (§12). */
+    readonly socket?: {
+        readonly remoteAddress?: string;
+    };
+}
+export interface DevResponseShape {
+    statusCode: number;
+    readonly headersSent?: boolean;
+    setHeader(name: string, value: string): unknown;
+    removeHeader?(name: string): unknown;
+    write?(chunk: unknown, ...rest: unknown[]): boolean;
+    end(body?: string): unknown;
+}
+export type DevMiddleware = (request: DevRequestShape, response: DevResponseShape, next: (error?: unknown) => void) => void;
+/** What the `config` hook adds for the policy (Vite merges it into the app's config). */
+export interface DevFilesPatch {
+    readonly server: {
+        readonly fs: {
+            readonly strict: true;
+            readonly allow: string[];
+            readonly deny: string[];
+        };
+    };
+}
+export interface DevFilesOptions {
+    /** Further files or folders the browser loads (relative to the Vite root, or absolute). */
+    readonly allow?: readonly string[];
+    /** Further Vite globs the dev server never serves (added to DEV_FILES_DENY). */
+    readonly deny?: readonly string[];
+}
+/**
+ * The dev file policy of one Vite config (one plugin instance). `owner` `dev-host` is the copy the
+ * Vite host of `dokebi dev` adds: it stays inactive when the app's config has `dokebiInertia()`.
+ */
+export declare class DevFilesPolicy {
+    #private;
+    constructor(logger: Logger, options: DevFilesOptions, owner: 'dokebi-inertia' | 'dev-host');
+    /** The deny entries this policy always keeps (DEV_FILES_DENY and the plugin's `deny`). */
+    get required(): string[];
+    /** The `config` hook (dev server only): the policy as a patch, and warnings for a weaker config. */
+    config(raw: unknown, command: 'build' | 'serve'): DevFilesPatch | null;
+    /** The `configResolved` hook: repairs what a later plugin loosened and keeps the live config. */
+    configResolved(config: ResolvedFilesShape): void;
+    /** The middleware to add before Vite's own (undefined when this copy is inactive). */
+    middleware(): DevMiddleware | undefined;
+}
+/** The Vite plugin of the policy alone (what the Vite host of `dokebi dev` adds). */
+export interface DokebiDevFilesPlugin {
+    readonly name: 'dokebi-inertia:dev-files';
+    readonly enforce: 'pre';
+    config(config: unknown, env: {
+        command: 'build' | 'serve';
+    }): DevFilesPatch | null;
+    configResolved(config: ResolvedFilesShape): void;
+    configureServer(server: {
+        readonly middlewares: {
+            use(handler: DevMiddleware): unknown;
+        };
+    }): void;
+}
+/**
+ * The dev file policy as a plugin of its own, for a vite.config without `dokebiInertia()` (which
+ * carries the same policy): the Vite host of `dokebi dev` adds it; it stays inactive next to
+ * `dokebiInertia()`.
+ */
+export declare function dokebiDevFiles(logger: Logger, options?: DevFilesOptions): DokebiDevFilesPlugin;