revojs 0.0.87 → 0.1.0

package/dist/locale/index.d.ts

@@ -1,26 +0,0 @@
-import { type Descriptor, Scope, type State } from "../signals";
-export type LocaleOptions = {
-    locales: Record<string, Record<string, string>>;
-    defaultLocale: string;
-    input: string;
-};
-export type LocaleContext = {
-    locale: State<string | undefined>;
-    messages: State<Record<string, string> | undefined>;
-    options: LocaleOptions;
-};
-export declare function provideLocaleContext(scope: Scope, options: LocaleOptions): {
-    locale: State<string | undefined>;
-    messages: State<Record<string, string> | undefined>;
-    options: LocaleOptions;
-    $: (key: string) => () => string | number | symbol;
-    $date: (date?: Date, options?: Intl.DateTimeFormatOptions) => string | undefined;
-};
-export declare function useLocale<T extends LocaleContext>(scope: Scope, context?: Descriptor<T>): {
-    locale: State<string | undefined>;
-    messages: State<Record<string, string> | undefined>;
-    options: LocaleOptions;
-    $: (key: keyof T["options"]["locales"][keyof T["options"]["locales"]]) => () => string | number | symbol;
-    $date: (date?: Date, options?: Intl.DateTimeFormatOptions) => string | undefined;
-};
-export declare const LOCALE_CONTEXT: Descriptor<LocaleContext>;

package/dist/radix/index.d.ts

@@ -1,12 +0,0 @@
-export type Match<T> = {
-    value?: T;
-    inputs: Record<string, string>;
-};
-export declare class Radix<T> {
-    value?: T;
-    input?: string;
-    children: Record<string, Radix<T>>;
-    constructor(input?: string);
-    insert(path: string, value: T): this;
-    match(path: string): Match<T>;
-}

package/dist/router/index.d.ts

@@ -1,45 +0,0 @@
-import { type Slot } from "../html";
-import { Radix } from "../radix";
-import { type Descriptor, Scope, type State } from "../signals";
-export type RouterOptions = {
-    routes: Record<string, Slot>;
-};
-export type RouterContext = {
-    url: State<URL | undefined>;
-    route: State<Slot | undefined>;
-    radix: Radix<Slot>;
-    navigator: EventTarget;
-    options: RouterOptions;
-};
-export declare class NavigateEvent extends Event {
-    constructor();
-}
-export declare class AfterNavigateEvent extends Event {
-    constructor();
-}
-export declare function provideRouterContext(scope: Scope, options: RouterOptions): {
-    url: State<URL | undefined>;
-    route: State<unknown>;
-    navigator: EventTarget;
-    options: RouterOptions;
-    radix: Radix<unknown>;
-    navigate: (path: string) => void;
-    anchorNavigate: (event: Event) => void;
-};
-export declare function useRouter<T extends RouterContext>(scope: Scope, context?: Descriptor<T>): {
-    url: State<URL | undefined>;
-    route: State<unknown>;
-    navigator: EventTarget;
-    options: RouterOptions;
-    radix: Radix<unknown>;
-    navigate: (path: string) => void;
-    anchorNavigate: (event: Event) => void;
-};
-export declare const Page: import("..").ComponentConstructor<import("..").Events, import("..").Attributes>;
-export declare const ROUTER_CONTEXT: Descriptor<RouterContext>;
-declare global {
-    interface ElementEventMap {
-        navigate: NavigateEvent;
-        afterNavigate: AfterNavigateEvent;
-    }
-}

package/dist/runtime/index.d.ts

@@ -1,55 +0,0 @@
-import { type Chain, type Handle, type ResponseOptions } from "../http";
-import { Radix } from "../radix";
-import { Scope, type State } from "../signals";
-export type Route = {
-    fetch: Handle;
-};
-export type Middleware = {
-    fetch: Chain;
-};
-export type Runtime = {
-    radix: Radix<Route>;
-    middlewares: Array<Middleware>;
-    fetch: (scope: Scope) => Promise<Response>;
-};
-export type RuntimeContext<T = Record<string, unknown>> = {
-    tasks: Array<Promise<unknown>>;
-    states: Record<string, State<unknown>>;
-    request: Request;
-    response: ResponseOptions;
-    variables: T;
-};
-export type RouteContext = {
-    inputs: State<Record<string, string>>;
-};
-export type AsyncOptions<T> = {
-    viewTransition?: false | string;
-    catch?: (error: T) => void | Promise<void>;
-};
-export declare function isRoute<T>(value?: T): value is Route & T;
-export declare function useRuntime<T = Record<string, unknown>>(scope: Scope): RuntimeContext<T>;
-export declare function useRoute(scope: Scope): RouteContext;
-export declare function useRoutes(): Promise<Record<string, unknown>>;
-export declare function useAssets(): Promise<Record<string, string>>;
-export declare function useLocales(): Promise<Record<string, Record<string, string>>>;
-export declare function defineRoute(route: Route): Route;
-export declare function defineMiddleware(middleware: Middleware): Middleware;
-export declare function fileName(path: string): string | undefined;
-export declare function toPath(value: string): (string | undefined)[];
-export declare function $fetch<T>(scope: Scope, input: string | URL, options?: RequestInit): Promise<T>;
-export declare function useState<T>(scope: Scope, name: string): State<T | undefined>;
-export declare function useState<T>(scope: Scope, name: string, value: T): State<T>;
-export declare function useAsync<T, TError = Error>(scope: Scope, name: string, invoke: () => Promise<T>, defaultOptions?: AsyncOptions<TError>): {
-    state: State<T | undefined>;
-    isLoading: State<boolean>;
-    execute: (options?: AsyncOptions<TError>) => Promise<T | undefined>;
-};
-export declare function useFetch<T, TError = Error>(scope: Scope, input: string | URL, options?: RequestInit & AsyncOptions<TError>): {
-    state: State<T | undefined>;
-    isLoading: State<boolean>;
-    execute: (options?: AsyncOptions<TError> | undefined) => Promise<T | undefined>;
-};
-export declare function createRuntime(): Promise<Runtime>;
-export declare let STATES: Record<string, unknown>;
-export declare const RUNTIME_CONTEXT: import("..").Descriptor<RuntimeContext<Record<string, unknown>>>;
-export declare const ROUTE_CONTEXT: import("..").Descriptor<RouteContext>;

package/dist/schema/index.d.ts

@@ -1,22 +0,0 @@
-export type Issue = {
-    readonly message: string;
-};
-export type Success<T> = {
-    readonly value: T;
-};
-export type Failure = {
-    readonly issues: ReadonlyArray<Issue>;
-};
-export type Result<Output> = Success<Output> | Failure;
-export type Schema<T = unknown, TOutput = T> = {
-    readonly "~standard": {
-        readonly validate: (value: unknown) => Result<TOutput>;
-        readonly types?: {
-            readonly input: T;
-            readonly output: TOutput;
-        };
-    };
-};
-export type InferInput<T extends Schema> = NonNullable<T["~standard"]["types"]>["input"];
-export type InferOutput<T extends Schema> = NonNullable<T["~standard"]["types"]>["output"];
-export declare function isFailure<T>(result: Result<T>): result is Failure;

package/dist/signals/index.d.ts

@@ -1,44 +0,0 @@
-declare const descriptor: unique symbol;
-export type Value<T> = T | (() => Value<T>);
-export type Descriptor<T> = string & {
-    [descriptor]: T;
-};
-export interface State<T> {
-    value: T;
-}
-export declare class StopEvent extends Event {
-    constructor();
-}
-export declare class Scope extends EventTarget {
-    parentScope?: Scope;
-    readonly context: Map<string, unknown>;
-    constructor(parentScope?: Scope);
-    getContext<T>(input: Descriptor<T>): T;
-    setContext<T>(input: Descriptor<T>, value: T): void;
-    onStop(input: (event: StopEvent) => void): void;
-    stop(): boolean;
-}
-export declare class Compute<T = void> extends Scope {
-    readonly invoke: (scope: Scope) => T;
-    constructor(parentScope: Scope, invoke: (scope: Scope) => T);
-    run(): T;
-}
-export declare class Handler<T extends object> implements ProxyHandler<T> {
-    get(target: T, key: string | symbol): unknown;
-    set(target: T, key: string | symbol, value: unknown): boolean;
-}
-export declare function createState<T>(): State<T | undefined>;
-export declare function createState<T>(value: T): State<T>;
-export declare function createCompute<T>(scope: Scope, invoke: (scope: Scope) => T): T;
-export declare function createMemo<T>(scope: Scope, invoke: (scope: Scope) => T): State<T>;
-export declare function fromValue<T>(value: Value<T>): T;
-export declare function untrack<T>(invoke: () => T): T;
-export declare function defineContext<T>(key: string): Descriptor<T>;
-export declare let activeCompute: Compute | undefined;
-export declare const targets: WeakMap<object, Map<string | symbol, Set<Compute<void>>>>;
-declare global {
-    interface ElementEventMap {
-        stop: StopEvent;
-    }
-}
-export {};