@zuplo/cli 6.73.30 → 6.73.31

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/middleware/secure-headers/secure-headers.d.ts

@@ -0,0 +1,109 @@
+/**
+ * @module
+ * Secure Headers Middleware for Hono.
+ */
+import type { Context } from '../../context';
+import type { MiddlewareHandler } from '../../types';
+import type { PermissionsPolicyDirective } from './permissions-policy';
+export type SecureHeadersVariables = {
+    secureHeadersNonce?: string;
+};
+export type ContentSecurityPolicyOptionHandler = (ctx: Context, directive: string) => string;
+type ContentSecurityPolicyOptionValue = (string | ContentSecurityPolicyOptionHandler)[];
+interface ContentSecurityPolicyOptions {
+    defaultSrc?: ContentSecurityPolicyOptionValue;
+    baseUri?: ContentSecurityPolicyOptionValue;
+    childSrc?: ContentSecurityPolicyOptionValue;
+    connectSrc?: ContentSecurityPolicyOptionValue;
+    fontSrc?: ContentSecurityPolicyOptionValue;
+    formAction?: ContentSecurityPolicyOptionValue;
+    frameAncestors?: ContentSecurityPolicyOptionValue;
+    frameSrc?: ContentSecurityPolicyOptionValue;
+    imgSrc?: ContentSecurityPolicyOptionValue;
+    manifestSrc?: ContentSecurityPolicyOptionValue;
+    mediaSrc?: ContentSecurityPolicyOptionValue;
+    objectSrc?: ContentSecurityPolicyOptionValue;
+    reportTo?: string;
+    reportUri?: string | string[];
+    sandbox?: ContentSecurityPolicyOptionValue;
+    scriptSrc?: ContentSecurityPolicyOptionValue;
+    scriptSrcAttr?: ContentSecurityPolicyOptionValue;
+    scriptSrcElem?: ContentSecurityPolicyOptionValue;
+    styleSrc?: ContentSecurityPolicyOptionValue;
+    styleSrcAttr?: ContentSecurityPolicyOptionValue;
+    styleSrcElem?: ContentSecurityPolicyOptionValue;
+    upgradeInsecureRequests?: ContentSecurityPolicyOptionValue;
+    workerSrc?: ContentSecurityPolicyOptionValue;
+    requireTrustedTypesFor?: ContentSecurityPolicyOptionValue;
+    trustedTypes?: ContentSecurityPolicyOptionValue;
+}
+interface ReportToOptions {
+    group: string;
+    max_age: number;
+    endpoints: ReportToEndpoint[];
+}
+interface ReportToEndpoint {
+    url: string;
+}
+interface ReportingEndpointOptions {
+    name: string;
+    url: string;
+}
+type PermissionsPolicyValue = '*' | 'self' | 'src' | 'none' | string;
+type PermissionsPolicyOptions = Partial<Record<PermissionsPolicyDirective, PermissionsPolicyValue[] | boolean>>;
+type overridableHeader = boolean | string;
+interface SecureHeadersOptions {
+    contentSecurityPolicy?: ContentSecurityPolicyOptions;
+    contentSecurityPolicyReportOnly?: ContentSecurityPolicyOptions;
+    crossOriginEmbedderPolicy?: overridableHeader;
+    crossOriginResourcePolicy?: overridableHeader;
+    crossOriginOpenerPolicy?: overridableHeader;
+    originAgentCluster?: overridableHeader;
+    referrerPolicy?: overridableHeader;
+    reportingEndpoints?: ReportingEndpointOptions[];
+    reportTo?: ReportToOptions[];
+    strictTransportSecurity?: overridableHeader;
+    xContentTypeOptions?: overridableHeader;
+    xDnsPrefetchControl?: overridableHeader;
+    xDownloadOptions?: overridableHeader;
+    xFrameOptions?: overridableHeader;
+    xPermittedCrossDomainPolicies?: overridableHeader;
+    xXssProtection?: overridableHeader;
+    removePoweredBy?: boolean;
+    permissionsPolicy?: PermissionsPolicyOptions;
+}
+export declare const NONCE: ContentSecurityPolicyOptionHandler;
+/**
+ * Secure Headers Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/secure-headers}
+ *
+ * @param {Partial<SecureHeadersOptions>} [customOptions] - The options for the secure headers middleware.
+ * @param {ContentSecurityPolicyOptions} [customOptions.contentSecurityPolicy] - Settings for the Content-Security-Policy header.
+ * @param {ContentSecurityPolicyOptions} [customOptions.contentSecurityPolicyReportOnly] - Settings for the Content-Security-Policy-Report-Only header.
+ * @param {overridableHeader} [customOptions.crossOriginEmbedderPolicy=false] - Settings for the Cross-Origin-Embedder-Policy header.
+ * @param {overridableHeader} [customOptions.crossOriginResourcePolicy=true] - Settings for the Cross-Origin-Resource-Policy header.
+ * @param {overridableHeader} [customOptions.crossOriginOpenerPolicy=true] - Settings for the Cross-Origin-Opener-Policy header.
+ * @param {overridableHeader} [customOptions.originAgentCluster=true] - Settings for the Origin-Agent-Cluster header.
+ * @param {overridableHeader} [customOptions.referrerPolicy=true] - Settings for the Referrer-Policy header.
+ * @param {ReportingEndpointOptions[]} [customOptions.reportingEndpoints] - Settings for the Reporting-Endpoints header.
+ * @param {ReportToOptions[]} [customOptions.reportTo] - Settings for the Report-To header.
+ * @param {overridableHeader} [customOptions.strictTransportSecurity=true] - Settings for the Strict-Transport-Security header.
+ * @param {overridableHeader} [customOptions.xContentTypeOptions=true] - Settings for the X-Content-Type-Options header.
+ * @param {overridableHeader} [customOptions.xDnsPrefetchControl=true] - Settings for the X-DNS-Prefetch-Control header.
+ * @param {overridableHeader} [customOptions.xDownloadOptions=true] - Settings for the X-Download-Options header.
+ * @param {overridableHeader} [customOptions.xFrameOptions=true] - Settings for the X-Frame-Options header.
+ * @param {overridableHeader} [customOptions.xPermittedCrossDomainPolicies=true] - Settings for the X-Permitted-Cross-Domain-Policies header.
+ * @param {overridableHeader} [customOptions.xXssProtection=true] - Settings for the X-XSS-Protection header.
+ * @param {boolean} [customOptions.removePoweredBy=true] - Settings for remove X-Powered-By header.
+ * @param {PermissionsPolicyOptions} [customOptions.permissionsPolicy] - Settings for the Permissions-Policy header.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ * app.use(secureHeaders())
+ * ```
+ */
+export declare const secureHeaders: (customOptions?: SecureHeadersOptions) => MiddlewareHandler;
+export {};

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/middleware/serve-static/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @module
+ * Serve Static Middleware for Hono.
+ */
+import type { Context, Data } from '../../context';
+import type { Env, MiddlewareHandler } from '../../types';
+export type ServeStaticOptions<E extends Env = Env> = {
+    root?: string;
+    path?: string;
+    precompressed?: boolean;
+    mimes?: Record<string, string>;
+    rewriteRequestPath?: (path: string) => string;
+    onFound?: (path: string, c: Context<E>) => void | Promise<void>;
+    onNotFound?: (path: string, c: Context<E>) => void | Promise<void>;
+};
+/**
+ * This middleware is not directly used by the user. Create a wrapper specifying `getContent()` by the environment such as Deno or Bun.
+ */
+export declare const serveStatic: <E extends Env = Env>(options: ServeStaticOptions<E> & {
+    getContent: (path: string, c: Context<E>) => Promise<Data | Response | null>;
+    /**
+     *
+     * `join` option according to the runtime. Example `import { join } from 'node:path`. If not specified, it will fall back to the default join function.`
+     */
+    join?: (...paths: string[]) => string;
+    /**
+     * @deprecated Currently, `pathResolve` is no longer used.
+     */
+    pathResolve?: (path: string) => string;
+    isDir?: (path: string) => boolean | undefined | Promise<boolean | undefined>;
+}) => MiddlewareHandler;

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/middleware/serve-static/path.d.ts

@@ -0,0 +1,5 @@
+/**
+ * `defaultJoin` does not support Windows paths and always uses `/` separators.
+ * If you need Windows path support, please use `join` exported from `node:path` etc. instead.
+ */
+export declare const defaultJoin: (...paths: string[]) => string;

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/middleware/timeout/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @module
+ * Timeout Middleware for Hono.
+ */
+import type { Context } from '../../context';
+import { HTTPException } from '../../http-exception';
+import type { MiddlewareHandler } from '../../types';
+export type HTTPExceptionFunction = (context: Context) => HTTPException;
+/**
+ * Timeout Middleware for Hono.
+ *
+ * @param {number} duration - The timeout duration in milliseconds.
+ * @param {HTTPExceptionFunction | HTTPException} [exception=defaultTimeoutException] - The exception to throw when the timeout occurs. Can be a function that returns an HTTPException or an HTTPException object.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(
+ *   '/long-request',
+ *   timeout(5000) // Set timeout to 5 seconds
+ * )
+ *
+ * app.get('/long-request', async (c) => {
+ *   await someLongRunningFunction()
+ *   return c.text('Completed within time limit')
+ * })
+ * ```
+ */
+export declare const timeout: (duration: number, exception?: HTTPExceptionFunction | HTTPException) => MiddlewareHandler;

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/middleware/timing/index.d.ts

@@ -0,0 +1,7 @@
+import type { TimingVariables } from './timing';
+export { TimingVariables };
+export { timing, setMetric, startTime, endTime, wrapTime } from './timing';
+declare module '../..' {
+    interface ContextVariableMap extends TimingVariables {
+    }
+}

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/middleware/timing/timing.d.ts

@@ -0,0 +1,129 @@
+/**
+ * @module
+ * Server-Timing Middleware for Hono.
+ */
+import type { Context } from '../../context';
+import type { MiddlewareHandler } from '../../types';
+import '../../context';
+export type TimingVariables = {
+    metric?: {
+        headers: string[];
+        timers: Map<string, Timer>;
+    };
+};
+interface Timer {
+    description?: string;
+    start: number;
+}
+interface TimingOptions {
+    total?: boolean;
+    enabled?: boolean | ((c: Context) => boolean);
+    totalDescription?: string;
+    autoEnd?: boolean;
+    crossOrigin?: boolean | string | ((c: Context) => boolean | string);
+}
+/**
+ * Server-Timing Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/timing}
+ *
+ * @param {TimingOptions} [config] - The options for the timing middleware.
+ * @param {boolean} [config.total=true] - Show the total response time.
+ * @param {boolean | ((c: Context) => boolean)} [config.enabled=true] - Whether timings should be added to the headers or not.
+ * @param {string} [config.totalDescription=Total Response Time] - Description for the total response time.
+ * @param {boolean} [config.autoEnd=true] - If `startTime()` should end automatically at the end of the request.
+ * @param {boolean | string | ((c: Context) => boolean | string)} [config.crossOrigin=false] - The origin this timings header should be readable.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * // add the middleware to your router
+ * app.use(timing());
+ *
+ * app.get('/', async (c) => {
+ *   // add custom metrics
+ *   setMetric(c, 'region', 'europe-west3')
+ *
+ *   // add custom metrics with timing, must be in milliseconds
+ *   setMetric(c, 'custom', 23.8, 'My custom Metric')
+ *
+ *   // start a new timer
+ *   startTime(c, 'db');
+ *
+ *   const data = await db.findMany(...);
+ *
+ *   // end the timer
+ *   endTime(c, 'db');
+ *
+ *   return c.json({ response: data });
+ * });
+ * ```
+ */
+export declare const timing: (config?: TimingOptions) => MiddlewareHandler;
+interface SetMetric {
+    (c: Context, name: string, value: number, description?: string, precision?: number): void;
+    (c: Context, name: string, description?: string): void;
+}
+/**
+ * Set a metric for the timing middleware.
+ *
+ * @param {Context} c - The context of the request.
+ * @param {string} name - The name of the metric.
+ * @param {number | string} [valueDescription] - The value or description of the metric.
+ * @param {string} [description] - The description of the metric.
+ * @param {number} [precision] - The precision of the metric value.
+ *
+ * @example
+ * ```ts
+ * setMetric(c, 'region', 'europe-west3')
+ * setMetric(c, 'custom', 23.8, 'My custom Metric')
+ * ```
+ */
+export declare const setMetric: SetMetric;
+/**
+ * Start a timer for the timing middleware.
+ *
+ * @param {Context} c - The context of the request.
+ * @param {string} name - The name of the timer.
+ * @param {string} [description] - The description of the timer.
+ *
+ * @example
+ * ```ts
+ * startTime(c, 'db')
+ * ```
+ */
+export declare const startTime: (c: Context, name: string, description?: string) => void;
+/**
+ * End a timer for the timing middleware.
+ *
+ * @param {Context} c - The context of the request.
+ * @param {string} name - The name of the timer.
+ * @param {number} [precision] - The precision of the timer value.
+ *
+ * @example
+ * ```ts
+ * endTime(c, 'db')
+ * ```
+ */
+export declare const endTime: (c: Context, name: string, precision?: number) => void;
+/**
+ * Wrap a Promise to capture its duration.
+ * @param {Context} c - The context of the request.
+ * @param {string} name - The name of the timer.
+ * @param {Promise<T>} callable - The Promise to time.
+ * @param {string} [description] - The description of the timer.
+ * @param {number} [precision] - The precision of the timer value.
+ *
+ * @example
+ * ```ts
+ *   // Instead of this:
+ *   const data = await db.findMany(...);
+ *
+ *   // do this:
+ *   const data = await wrapTime(c, 'query', db.findMany(...));
+ * ```
+ * */
+export declare function wrapTime<T>(c: Context, name: string, callable: Promise<T>, description?: string, precision?: number): Promise<T>;
+export {};

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/middleware/trailing-slash/index.d.ts

@@ -0,0 +1,94 @@
+/**
+ * @module
+ * Trailing Slash Middleware for Hono.
+ */
+import type { MiddlewareHandler } from '../../types';
+type TrimTrailingSlashOptions = {
+    /**
+     * If `true`, the middleware will always redirect requests with a trailing slash
+     * before executing handlers.
+     * This is useful for routes with wildcards (`*`).
+     * If `false` (default), it will only redirect when the route is not found (404).
+     * @default false
+     */
+    alwaysRedirect?: boolean;
+};
+/**
+ * Trailing Slash Middleware for Hono.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/trailing-slash}
+ *
+ * @param {TrimTrailingSlashOptions} options - The options for the middleware.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(trimTrailingSlash())
+ * app.get('/about/me/', (c) => c.text('With Trailing Slash'))
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With alwaysRedirect option for wildcard routes
+ * const app = new Hono()
+ *
+ * app.use(trimTrailingSlash({ alwaysRedirect: true }))
+ * app.get('/my-path/*', (c) => c.text('Wildcard route'))
+ * ```
+ */
+export declare const trimTrailingSlash: (options?: TrimTrailingSlashOptions) => MiddlewareHandler;
+type AppendTrailingSlashOptions = {
+    /**
+     * If `true`, the middleware will always redirect requests without a trailing slash
+     * before executing handlers.
+     * This is useful for routes with wildcards (`*`).
+     * If `false` (default), it will only redirect when the route is not found (404).
+     * @default false
+     */
+    alwaysRedirect?: boolean;
+    /**
+     * A function that determines whether to skip the redirect for a given path.
+     * If the function returns `true`, the redirect will be skipped.
+     * @param path - The request path
+     * @returns `true` to skip the redirect
+     *
+     * @example
+     * ```ts
+     * // Skip redirect for paths with file extensions
+     * app.use(appendTrailingSlash({
+     *   alwaysRedirect: true,
+     *   skip: (path) => /\.\w+$/.test(path),
+     * }))
+     * ```
+     */
+    skip?: (path: string) => boolean;
+};
+/**
+ * Append trailing slash middleware for Hono.
+ * Append a trailing slash to the URL if it doesn't have one. For example, `/path/to/page` will be redirected to `/path/to/page/`.
+ *
+ * @see {@link https://hono.dev/docs/middleware/builtin/trailing-slash}
+ *
+ * @param {AppendTrailingSlashOptions} options - The options for the middleware.
+ * @returns {MiddlewareHandler} The middleware handler function.
+ *
+ * @example
+ * ```ts
+ * const app = new Hono()
+ *
+ * app.use(appendTrailingSlash())
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With alwaysRedirect option for wildcard routes
+ * const app = new Hono()
+ *
+ * app.use(appendTrailingSlash({ alwaysRedirect: true }))
+ * app.get('/my-path/*', (c) => c.text('Wildcard route'))
+ * ```
+ */
+export declare const appendTrailingSlash: (options?: AppendTrailingSlashOptions) => MiddlewareHandler;
+export {};

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/preset/quick.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @module
+ * The preset that uses `LinearRouter`.
+ */
+import { HonoBase } from '../hono-base';
+import type { HonoOptions } from '../hono-base';
+import type { BlankEnv, BlankSchema, Env, Schema } from '../types';
+export declare class Hono<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
+    constructor(options?: HonoOptions<E>);
+}

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/preset/tiny.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @module
+ * The preset that uses `PatternRouter`.
+ */
+import { HonoBase } from '../hono-base';
+import type { HonoOptions } from '../hono-base';
+import type { BlankEnv, BlankSchema, Env, Schema } from '../types';
+export declare class Hono<E extends Env = BlankEnv, S extends Schema = BlankSchema, BasePath extends string = '/'> extends HonoBase<E, S, BasePath> {
+    constructor(options?: HonoOptions<E>);
+}

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/request/constants.d.ts

@@ -0,0 +1 @@
+export declare const GET_MATCH_RESULT: unique symbol;