npm - @zuplo/cli - Versions diffs - 6.73.30 → 6.73.31 - Mend

@zuplo/cli 6.73.30 → 6.73.31

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (614) hide show

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

@@ -0,0 +1,324 @@
+import { GET_MATCH_RESULT } from './request/constants';
+import type { Result } from './router';
+import type { Input, InputToDataByTarget, ParamKeyToRecord, ParamKeys, RemoveQuestion, RouterRoute, ValidationTargets } from './types';
+import type { BodyData, ParseBodyOptions } from './utils/body';
+import type { CustomHeader, RequestHeader } from './utils/headers';
+import type { Simplify, UnionToIntersection } from './utils/types';
+type Body = {
+    json: any;
+    text: string;
+    arrayBuffer: ArrayBuffer;
+    blob: Blob;
+    formData: FormData;
+};
+type BodyCache = Partial<Body>;
+export declare class HonoRequest<P extends string = '/', I extends Input['out'] = {}> {
+    /**
+     * `.raw` can get the raw Request object.
+     *
+     * @see {@link https://hono.dev/docs/api/request#raw}
+     *
+     * @example
+     * ```ts
+     * // For Cloudflare Workers
+     * app.post('/', async (c) => {
+     *   const metadata = c.req.raw.cf?.hostMetadata?
+     *   ...
+     * })
+     * ```
+     */
+    raw: Request;
+    routeIndex: number;
+    /**
+     * `.path` can get the pathname of the request.
+     *
+     * @see {@link https://hono.dev/docs/api/request#path}
+     *
+     * @example
+     * ```ts
+     * app.get('/about/me', (c) => {
+     *   const pathname = c.req.path // `/about/me`
+     * })
+     * ```
+     */
+    path: string;
+    bodyCache: BodyCache;
+    constructor(request: Request, path?: string, matchResult?: Result<[unknown, RouterRoute]>);
+    /**
+     * `.req.param()` gets the path parameters.
+     *
+     * @see {@link https://hono.dev/docs/api/routing#path-parameter}
+     *
+     * @example
+     * ```ts
+     * const name = c.req.param('name')
+     * // or all parameters at once
+     * const { id, comment_id } = c.req.param()
+     * ```
+     */
+    param<P2 extends ParamKeys<P> = ParamKeys<P>>(key: string extends P ? never : P2 extends `${infer _}?` ? never : P2): string;
+    param<P2 extends RemoveQuestion<ParamKeys<P>> = RemoveQuestion<ParamKeys<P>>>(key: P2): string | undefined;
+    param(key: string): string | undefined;
+    param<P2 extends string = P>(): Simplify<UnionToIntersection<ParamKeyToRecord<ParamKeys<P2>>>>;
+    /**
+     * `.query()` can get querystring parameters.
+     *
+     * @see {@link https://hono.dev/docs/api/request#query}
+     *
+     * @example
+     * ```ts
+     * // Query params
+     * app.get('/search', (c) => {
+     *   const query = c.req.query('q')
+     * })
+     *
+     * // Get all params at once
+     * app.get('/search', (c) => {
+     *   const { q, limit, offset } = c.req.query()
+     * })
+     * ```
+     */
+    query(key: string): string | undefined;
+    query(): Record<string, string>;
+    /**
+     * `.queries()` can get multiple querystring parameter values, e.g. /search?tags=A&tags=B
+     *
+     * @see {@link https://hono.dev/docs/api/request#queries}
+     *
+     * @example
+     * ```ts
+     * app.get('/search', (c) => {
+     *   // tags will be string[]
+     *   const tags = c.req.queries('tags')
+     * })
+     * ```
+     */
+    queries(key: string): string[] | undefined;
+    queries(): Record<string, string[]>;
+    /**
+     * `.header()` can get the request header value.
+     *
+     * @see {@link https://hono.dev/docs/api/request#header}
+     *
+     * @example
+     * ```ts
+     * app.get('/', (c) => {
+     *   const userAgent = c.req.header('User-Agent')
+     * })
+     * ```
+     */
+    header(name: RequestHeader): string | undefined;
+    header(name: string): string | undefined;
+    header(): Record<RequestHeader | (string & CustomHeader), string>;
+    /**
+     * `.parseBody()` can parse Request body of type `multipart/form-data` or `application/x-www-form-urlencoded`
+     *
+     * @see {@link https://hono.dev/docs/api/request#parsebody}
+     *
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.parseBody()
+     * })
+     * ```
+     */
+    parseBody<Options extends Partial<ParseBodyOptions>, T extends BodyData<Options>>(options?: Options): Promise<T>;
+    parseBody<T extends BodyData>(options?: Partial<ParseBodyOptions>): Promise<T>;
+    /**
+     * `.json()` can parse Request body of type `application/json`
+     *
+     * @see {@link https://hono.dev/docs/api/request#json}
+     *
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.json()
+     * })
+     * ```
+     */
+    json<T = any>(): Promise<T>;
+    /**
+     * `.text()` can parse Request body of type `text/plain`
+     *
+     * @see {@link https://hono.dev/docs/api/request#text}
+     *
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.text()
+     * })
+     * ```
+     */
+    text(): Promise<string>;
+    /**
+     * `.arrayBuffer()` parse Request body as an `ArrayBuffer`
+     *
+     * @see {@link https://hono.dev/docs/api/request#arraybuffer}
+     *
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.arrayBuffer()
+     * })
+     * ```
+     */
+    arrayBuffer(): Promise<ArrayBuffer>;
+    /**
+     * `.bytes()` parses the request body as a `Uint8Array`.
+     *
+     * @see {@link https://hono.dev/docs/api/request#bytes}
+     *
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.bytes()
+     * })
+     * ```
+     */
+    bytes(): Promise<Uint8Array>;
+    /**
+     * Parses the request body as a `Blob`.
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.blob();
+     * });
+     * ```
+     * @see https://hono.dev/docs/api/request#blob
+     */
+    blob(): Promise<Blob>;
+    /**
+     * Parses the request body as `FormData`.
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.formData();
+     * });
+     * ```
+     * @see https://hono.dev/docs/api/request#formdata
+     */
+    formData(): Promise<FormData>;
+    /**
+     * Adds validated data to the request.
+     *
+     * @param target - The target of the validation.
+     * @param data - The validated data to add.
+     */
+    addValidatedData(target: keyof ValidationTargets, data: {}): void;
+    /**
+     * Gets validated data from the request.
+     *
+     * @param target - The target of the validation.
+     * @returns The validated data.
+     *
+     * @see https://hono.dev/docs/api/request#valid
+     */
+    valid<T extends keyof I & keyof ValidationTargets>(target: T): InputToDataByTarget<I, T>;
+    /**
+     * `.url()` can get the request url strings.
+     *
+     * @see {@link https://hono.dev/docs/api/request#url}
+     *
+     * @example
+     * ```ts
+     * app.get('/about/me', (c) => {
+     *   const url = c.req.url // `http://localhost:8787/about/me`
+     *   ...
+     * })
+     * ```
+     */
+    get url(): string;
+    /**
+     * `.method()` can get the method name of the request.
+     *
+     * @see {@link https://hono.dev/docs/api/request#method}
+     *
+     * @example
+     * ```ts
+     * app.get('/about/me', (c) => {
+     *   const method = c.req.method // `GET`
+     * })
+     * ```
+     */
+    get method(): string;
+    get [GET_MATCH_RESULT](): Result<[unknown, RouterRoute]>;
+    /**
+     * `.matchedRoutes()` can return a matched route in the handler
+     *
+     * @deprecated
+     *
+     * Use matchedRoutes helper defined in "hono/route" instead.
+     *
+     * @see {@link https://hono.dev/docs/api/request#matchedroutes}
+     *
+     * @example
+     * ```ts
+     * app.use('*', async function logger(c, next) {
+     *   await next()
+     *   c.req.matchedRoutes.forEach(({ handler, method, path }, i) => {
+     *     const name = handler.name || (handler.length < 2 ? '[handler]' : '[middleware]')
+     *     console.log(
+     *       method,
+     *       ' ',
+     *       path,
+     *       ' '.repeat(Math.max(10 - path.length, 0)),
+     *       name,
+     *       i === c.req.routeIndex ? '<- respond from here' : ''
+     *     )
+     *   })
+     * })
+     * ```
+     */
+    get matchedRoutes(): RouterRoute[];
+    /**
+     * `routePath()` can retrieve the path registered within the handler
+     *
+     * @deprecated
+     *
+     * Use routePath helper defined in "hono/route" instead.
+     *
+     * @see {@link https://hono.dev/docs/api/request#routepath}
+     *
+     * @example
+     * ```ts
+     * app.get('/posts/:id', (c) => {
+     *   return c.json({ path: c.req.routePath })
+     * })
+     * ```
+     */
+    get routePath(): string;
+}
+/**
+ * Clones a HonoRequest's underlying raw Request object.
+ *
+ * This utility handles both consumed and unconsumed request bodies:
+ * - If the request body hasn't been consumed, it uses the native `clone()` method
+ * - If the request body has been consumed, it reconstructs a new Request using cached body data
+ *
+ * This is particularly useful when you need to:
+ * - Process the same request body multiple times
+ * - Pass requests to external services after validation
+ *
+ * @param req - The HonoRequest object to clone
+ * @returns A Promise that resolves to a new Request object with the same properties
+ * @throws {HTTPException} If the request body was consumed directly via `req.raw`
+ *   without using HonoRequest methods (e.g., `req.json()`, `req.text()`), making it
+ *   impossible to reconstruct the body from cache
+ *
+ * @example
+ * ```ts
+ * // Clone after consuming the body (e.g., after validation)
+ * app.post('/forward',
+ *   validator('json', (data) => data),
+ *   async (c) => {
+ *     const validated = c.req.valid('json')
+ *     // Body has been consumed, but cloneRawRequest still works
+ *     const clonedReq = await cloneRawRequest(c.req)
+ *     return fetch('http://backend-service.com', clonedReq)
+ *   }
+ * )
+ * ```
+ */
+export declare const cloneRawRequest: (req: HonoRequest) => Promise<Request>;
+export {};

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/router/linear-router/index.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+/**
+ * @module
+ * LinearRouter for Hono.
+ */
+export { LinearRouter } from './router';

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/router/linear-router/router.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import type { Result, Router } from '../../router';
+export declare class LinearRouter<T> implements Router<T> {
+    name: string;
+    add(method: string, path: string, handler: T): void;
+    match(method: string, path: string): Result<T>;
+}

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/router/pattern-router/index.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+/**
+ * @module
+ * PatternRouter for Hono.
+ */
+export { PatternRouter } from './router';

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/router/pattern-router/router.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import type { Result, Router } from '../../router';
+export declare class PatternRouter<T> implements Router<T> {
+    name: string;
+    add(method: string, path: string, handler: T): void;
+    match(method: string, path: string): Result<T>;
+}

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/router/reg-exp-router/index.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+/**
+ * @module
+ * RegExpRouter for Hono.
+ */
+export { RegExpRouter } from './router';
+export { PreparedRegExpRouter, buildInitParams, serializeInitParams } from './prepared-router';

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/router/reg-exp-router/matcher.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import type { ParamIndexMap, Result, Router } from '../../router';
+export type HandlerData<T> = [T, ParamIndexMap][];
+export type StaticMap<T> = Record<string, Result<T>>;
+export type Matcher<T> = [RegExp, HandlerData<T>[], StaticMap<T>];
+export type MatcherMap<T> = Record<string, Matcher<T> | null>;
+export declare const emptyParam: string[];
+export declare function match<R extends Router<T>, T>(this: R, method: string, path: string): Result<T>;

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/router/reg-exp-router/node.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+export declare const PATH_ERROR: unique symbol;
+export type ParamAssocArray = [string, number][];
+export interface Context {
+    varIndex: number;
+}
+export declare class Node {
+    insert(tokens: readonly string[], index: number, paramMap: ParamAssocArray, context: Context, pathErrorCheckOnly: boolean): void;
+    buildRegExpStr(): string;
+}

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/router/reg-exp-router/prepared-router.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+import type { ParamIndexMap, Router } from '../../router';
+import type { MatcherMap } from './matcher';
+import { match } from './matcher';
+type RelocateMap = Record<string, ([(number | string)[], ParamIndexMap] | [(number | string)[]])[]>;
+export declare class PreparedRegExpRouter<T> implements Router<T> {
+    name: string;
+    constructor(matchers: MatcherMap<T>, relocateMap: RelocateMap);
+    add(method: string, path: string, handler: T): void;
+    protected buildAllMatchers(): MatcherMap<T>;
+    match: typeof match<Router<T>, T>;
+}
+export declare const buildInitParams: (params: {
+    paths: string[];
+}) => ConstructorParameters<typeof PreparedRegExpRouter>;
+export declare const serializeInitParams: (params: ConstructorParameters<typeof PreparedRegExpRouter>) => string;
+export {};

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/router/reg-exp-router/router.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+import type { Router } from '../../router';
+import type { MatcherMap } from './matcher';
+import { match } from './matcher';
+export declare class RegExpRouter<T> implements Router<T> {
+    name: string;
+    constructor();
+    add(method: string, path: string, handler: T): void;
+    match: typeof match<Router<T>, T>;
+    protected buildAllMatchers(): MatcherMap<T>;
+}

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/router/reg-exp-router/trie.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import type { ParamAssocArray } from './node';
+export type ReplacementMap = number[];
+export declare class Trie {
+    insert(path: string, index: number, pathErrorCheckOnly: boolean): ParamAssocArray;
+    buildRegExp(): [RegExp, ReplacementMap, ReplacementMap];
+}

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/router/smart-router/index.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+/**
+ * @module
+ * SmartRouter for Hono.
+ */
+export { SmartRouter } from './router';

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/router/smart-router/router.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+import type { Result, Router } from '../../router';
+export declare class SmartRouter<T> implements Router<T> {
+    name: string;
+    constructor(init: {
+        routers: Router<T>[];
+    });
+    add(method: string, path: string, handler: T): void;
+    match(method: string, path: string): Result<T>;
+    get activeRouter(): Router<T>;
+}

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/router/trie-router/index.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+/**
+ * @module
+ * TrieRouter for Hono.
+ */
+export { TrieRouter } from './router';

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/router/trie-router/node.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import type { Params } from '../../router';
+export declare class Node<T> {
+    constructor(method?: string, handler?: T, children?: Record<string, Node<T>>);
+    insert(method: string, path: string, handler: T): Node<T>;
+    search(method: string, path: string): [[T, Params][]];
+}

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/router/trie-router/router.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import type { Result, Router } from '../../router';
+export declare class TrieRouter<T> implements Router<T> {
+    name: string;
+    constructor();
+    add(method: string, path: string, handler: T): void;
+    match(method: string, path: string): Result<T>;
+}

package/node_modules/@zuplo/editor/node_modules/hono/dist/types/router.d.ts ADDED Viewed

@@ -0,0 +1,97 @@
+/**
+ * @module
+ * This module provides types definitions and variables for the routers.
+ */
+/**
+ * Constant representing all HTTP methods in uppercase.
+ */
+export declare const METHOD_NAME_ALL: "ALL";
+/**
+ * Constant representing all HTTP methods in lowercase.
+ */
+export declare const METHOD_NAME_ALL_LOWERCASE: "all";
+/**
+ * Array of supported HTTP methods.
+ */
+export declare const METHODS: readonly ["get", "post", "put", "delete", "options", "patch"];
+/**
+ * Error message indicating that a route cannot be added because the matcher is already built.
+ */
+export declare const MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+/**
+ * Interface representing a router.
+ *
+ * @template T - The type of the handler.
+ */
+export interface Router<T> {
+    /**
+     * The name of the router.
+     */
+    name: string;
+    /**
+     * Adds a route to the router.
+     *
+     * @param method - The HTTP method (e.g., 'get', 'post').
+     * @param path - The path for the route.
+     * @param handler - The handler for the route.
+     */
+    add(method: string, path: string, handler: T): void;
+    /**
+     * Matches a route based on the given method and path.
+     *
+     * @param method - The HTTP method (e.g., 'get', 'post').
+     * @param path - The path to match.
+     * @returns The result of the match.
+     */
+    match(method: string, path: string): Result<T>;
+}
+/**
+ * Type representing a map of parameter indices.
+ */
+export type ParamIndexMap = Record<string, number>;
+/**
+ * Type representing a stash of parameters.
+ */
+export type ParamStash = string[];
+/**
+ * Type representing a map of parameters.
+ */
+export type Params = Record<string, string>;
+/**
+ * Type representing the result of a route match.
+ *
+ * The result can be in one of two formats:
+ * 1. An array of handlers with their corresponding parameter index maps, followed by a parameter stash.
+ * 2. An array of handlers with their corresponding parameter maps.
+ *
+ * Example:
+ *
+ * [[handler, paramIndexMap][], paramArray]
+ * ```typescript
+ * [
+ *   [
+ *     [middlewareA, {}],                     // '*'
+ *     [funcA,       {'id': 0}],              // '/user/:id/*'
+ *     [funcB,       {'id': 0, 'action': 1}], // '/user/:id/:action'
+ *   ],
+ *   ['123', 'abc']
+ * ]
+ * ```
+ *
+ * [[handler, params][]]
+ * ```typescript
+ * [
+ *   [
+ *     [middlewareA, {}],                             // '*'
+ *     [funcA,       {'id': '123'}],                  // '/user/:id/*'
+ *     [funcB,       {'id': '123', 'action': 'abc'}], // '/user/:id/:action'
+ *   ]
+ * ]
+ * ```
+ */
+export type Result<T> = [[T, ParamIndexMap][], ParamStash] | [[T, Params][]];
+/**
+ * Error class representing an unsupported path error.
+ */
+export declare class UnsupportedPathError extends Error {
+}