acrylblends 0.8.1 → 0.9.0

package/plugins/acryl-router/src/core/jsx/streaming.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @module
+ * This module enables JSX to supports streaming Response.
+ */
+import type { HtmlEscapedString } from '../utils/html.ts';
+import type { FC, PropsWithChildren, Context as JSXContext } from './index.ts';
+import { JSXNode } from './base.ts';
+/**
+ * Used to specify nonce for scripts generated by `Suspense` and `ErrorBoundary`.
+ *
+ * @example
+ * ```tsx
+ * <StreamingContext.Provider value={{ scriptNonce: 'test-nonce' }}>
+ *   <Suspense fallback={<p>Loading...</p>}>
+ *     <Content />
+ *   </Suspense>
+ * </StreamingContext.Provider>
+ * ```
+ */
+export declare const StreamingContext: JSXContext<{
+    scriptNonce: string;
+} | null>;
+/**
+ * @experimental
+ * `Suspense` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const Suspense: FC<PropsWithChildren<{
+    fallback: any;
+}>>;
+/**
+ * @experimental
+ * `renderToReadableStream()` is an experimental feature.
+ * The API might be changed.
+ */
+export declare const renderToReadableStream: (content: HtmlEscapedString | JSXNode | Promise<HtmlEscapedString>, onError?: (e: unknown) => string | void) => ReadableStream<Uint8Array>;

package/plugins/acryl-router/src/core/jsx/types.d.ts

@@ -0,0 +1,36 @@
+/**
+ * All types exported from "acryl-router/jsx" are in this file.
+ */
+import type { Child, JSXNode } from './base.ts';
+import type { JSX } from './intrinsic-elements.ts';
+import type { DomEvent } from '../utils/types.ts';
+export type { Child, JSXNode, FC } from './base.ts';
+export type { RefObject } from './hooks/index.ts';
+export type { Context } from './context.ts';
+export type PropsWithChildren<P = unknown> = P & {
+    children?: Child | undefined;
+};
+export type CSSProperties = JSX.CSSProperties;
+/**
+ * React types
+ */
+type ReactElement<P = any, T = string | Function> = JSXNode & {
+    type: T;
+    props: P;
+    key: string | null;
+};
+type ReactNode = ReactElement | string | number | boolean | null | undefined;
+type ComponentClass<_P = {}, _S = {}> = unknown;
+export type { ReactElement, ReactNode, ComponentClass };
+export type Event = globalThis.Event;
+export type MouseEvent = DomEvent<'MouseEvent'>;
+export type KeyboardEvent = DomEvent<'KeyboardEvent'>;
+export type FocusEvent = DomEvent<'FocusEvent'>;
+export type ClipboardEvent = DomEvent<'ClipboardEvent'>;
+export type InputEvent = DomEvent<'InputEvent'>;
+export type PointerEvent = DomEvent<'PointerEvent'>;
+export type TouchEvent = DomEvent<'TouchEvent'>;
+export type WheelEvent = DomEvent<'WheelEvent'>;
+export type AnimationEvent = DomEvent<'AnimationEvent'>;
+export type TransitionEvent = DomEvent<'TransitionEvent'>;
+export type DragEvent = DomEvent<'DragEvent'>;

package/plugins/acryl-router/src/core/jsx/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const normalizeIntrinsicElementKey: (key: string) => string;
+export declare const isValidTagName: (name: unknown) => name is string;
+export declare const isValidAttributeName: (name: string) => boolean;
+export declare const styleObjectForEach: (style: Record<string, unknown>, fn: (key: string, value: string | null) => void) => void;

package/plugins/acryl-router/src/core/request/constants.d.ts

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

package/plugins/acryl-router/src/core/request.d.ts

@@ -0,0 +1,306 @@
+import { GET_MATCH_RESULT } from './request/constants.ts';
+import type { Result } from './router.ts';
+import type { Input, InputToDataByTarget, ParamKeyToRecord, ParamKeys, RemoveQuestion, RouterRoute, ValidationTargets } from './types.ts';
+import type { BodyData, ParseBodyOptions } from './utils/body.ts';
+import type { CustomHeader, RequestHeader } from './utils/headers.ts';
+import type { Simplify, UnionToIntersection } from './utils/types.ts';
+type Body = {
+    json: any;
+    text: string;
+    arrayBuffer: ArrayBuffer;
+    blob: Blob;
+    formData: FormData;
+};
+type BodyCache = Partial<Body>;
+export declare class AcrylRequest<P extends string = '/', I extends Input['out'] = {}> {
+    #private;
+    /**
+     * `.raw` can get the raw Request object.
+     *
+     *
+     * @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.
+     *
+     *
+     * @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.
+     *
+     *
+     * @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.
+     *
+     *
+     * @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
+     *
+     *
+     * @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.
+     *
+     *
+     * @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`
+     *
+     *
+     * @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`
+     *
+     *
+     * @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`
+     *
+     *
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.text()
+     * })
+     * ```
+     */
+    text(): Promise<string>;
+    /**
+     * `.arrayBuffer()` parse Request body as an `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`.
+     *
+     *
+     * @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();
+     * });
+     * ```
+     */
+    blob(): Promise<Blob>;
+    /**
+     * Parses the request body as `FormData`.
+     * @example
+     * ```ts
+     * app.post('/entry', async (c) => {
+     *   const body = await c.req.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.
+     *
+     */
+    valid<T extends keyof I & keyof ValidationTargets>(target: T): InputToDataByTarget<I, T>;
+    /**
+     * `.url` can get the request url strings.
+     *
+     *
+     * @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.
+     *
+     *
+     * @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 "acryl-router/route" instead.
+     *
+     *
+     * @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 "acryl-router/route" instead.
+     *
+     *
+     * @example
+     * ```ts
+     * app.get('/posts/:id', (c) => {
+     *   return c.json({ path: c.req.routePath })
+     * })
+     * ```
+     */
+    get routePath(): string;
+}
+/**
+ * Clones a AcrylRequest'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 AcrylRequest 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 AcrylRequest 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: AcrylRequest) => Promise<Request>;
+export {};

package/plugins/acryl-router/src/core/router/reg-exp-router/index.d.ts

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

package/plugins/acryl-router/src/core/router/reg-exp-router/matcher.d.ts

@@ -0,0 +1,7 @@
+import type { ParamIndexMap, Result, Router } from '../../router.ts';
+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/plugins/acryl-router/src/core/router/reg-exp-router/node.d.ts

@@ -0,0 +1,13 @@
+export declare const LABEL_REG_EXP_STR = "[^/]+";
+export declare const ONLY_WILDCARD_REG_EXP_STR = ".*";
+export declare const TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
+export declare const PATH_ERROR: unique symbol;
+export type ParamAssocArray = [string, number][];
+export interface Context {
+    varIndex: number;
+}
+export declare class Node {
+    #private;
+    insert(tokens: readonly string[], index: number, paramMap: ParamAssocArray, context: Context, isStatic: boolean): void;
+    buildRegExpStr(): string;
+}

package/plugins/acryl-router/src/core/router/reg-exp-router/prepared-router.d.ts

@@ -0,0 +1,17 @@
+import type { ParamIndexMap, Router } from '../../router.ts';
+import type { MatcherMap } from './matcher.ts';
+import { match } from './matcher.ts';
+type RelocateMap = Record<string, ([(number | string)[], ParamIndexMap] | [(number | string)[]])[]>;
+export declare class PreparedRegExpRouter<T> implements Router<T> {
+    #private;
+    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/plugins/acryl-router/src/core/router/reg-exp-router/router.d.ts

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

package/plugins/acryl-router/src/core/router/reg-exp-router/trie.d.ts

@@ -0,0 +1,8 @@
+import type { ParamAssocArray } from './node.ts';
+export type ReplacementMap = number[];
+export declare class Trie {
+    #private;
+    paths: Record<string, [number, ParamAssocArray]>;
+    insert(path: string, isStatic: boolean): void;
+    buildRegExp(): [RegExp, ReplacementMap, ReplacementMap];
+}

package/plugins/acryl-router/src/core/router/smart-router/index.d.ts

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

package/plugins/acryl-router/src/core/router/smart-router/router.d.ts

@@ -0,0 +1,11 @@
+import type { Result, Router } from '../../router.ts';
+export declare class SmartRouter<T> implements Router<T> {
+    #private;
+    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/plugins/acryl-router/src/core/router/trie-router/index.d.ts

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

package/plugins/acryl-router/src/core/router/trie-router/node.d.ts

@@ -0,0 +1,6 @@
+import type { Params } from '../../router.ts';
+export declare class Node<T> {
+    #private;
+    insert(method: string, path: string, handler: T): void;
+    search(method: string, path: string): [[T, Params][]];
+}

package/plugins/acryl-router/src/core/router/trie-router/router.d.ts

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

package/plugins/acryl-router/src/core/router/utils.d.ts

@@ -0,0 +1 @@
+export declare const createNullObject: () => any;

package/plugins/acryl-router/src/core/router.d.ts

@@ -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", "query"];
+/**
+ * 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 {
+}