tritio 0.1.0

package/dist/schema.d.ts

@@ -0,0 +1,127 @@
+import { Type } from 'typebox';
+export declare const t: {
+    Email: (options?: any) => Type.TString;
+    Numeric: (options?: any) => Type.TNumber;
+    Instantiate: typeof Type.Instantiate;
+    Extends: typeof Type.Extends;
+    ExtendsResult: typeof Type.ExtendsResult;
+    Script: typeof Type.Script;
+    Awaited: typeof Type.Awaited;
+    Capitalize: typeof Type.Capitalize;
+    Conditional: typeof Type.Conditional;
+    ConstructorParameters: typeof Type.ConstructorParameters;
+    Evaluate: typeof Type.Evaluate;
+    Exclude: typeof Type.Exclude;
+    Extract: typeof Type.Extract;
+    Index: typeof Type.Index;
+    InstanceType: typeof Type.InstanceType;
+    Interface: typeof Type.Interface;
+    KeyOf: typeof Type.KeyOf;
+    Lowercase: typeof Type.Lowercase;
+    Mapped: typeof Type.Mapped;
+    Module: typeof Type.Module;
+    NonNullable: typeof Type.NonNullable;
+    Omit: typeof Type.Omit;
+    Options: typeof Type.Options;
+    Parameters: typeof Type.Parameters;
+    Partial: typeof Type.Partial;
+    Pick: typeof Type.Pick;
+    ReadonlyType: typeof Type.ReadonlyType;
+    Required: typeof Type.Required;
+    ReturnType: typeof Type.ReturnType;
+    Uncapitalize: typeof Type.Uncapitalize;
+    Uppercase: typeof Type.Uppercase;
+    Codec: typeof Type.Codec;
+    Decode: typeof Type.Decode;
+    DecodeBuilder: typeof Type.DecodeBuilder;
+    Encode: typeof Type.Encode;
+    EncodeBuilder: typeof Type.EncodeBuilder;
+    IsCodec: typeof Type.IsCodec;
+    Immutable: typeof Type.Immutable;
+    IsImmutable: typeof Type.IsImmutable;
+    IsOptional: typeof Type.IsOptional;
+    Optional: typeof Type.Optional;
+    IsReadonly: typeof Type.IsReadonly;
+    Readonly: typeof Type.Readonly;
+    IsRefine: typeof Type.IsRefine;
+    Refine: typeof Type.Refine;
+    Any: typeof Type.Any;
+    IsAny: typeof Type.IsAny;
+    Array: typeof Type.Array;
+    IsArray: typeof Type.IsArray;
+    AsyncIterator: typeof Type.AsyncIterator;
+    IsAsyncIterator: typeof Type.IsAsyncIterator;
+    Base: typeof Type.Base;
+    IsBase: typeof Type.IsBase;
+    BigInt: typeof Type.BigInt;
+    IsBigInt: typeof Type.IsBigInt;
+    Boolean: typeof Type.Boolean;
+    IsBoolean: typeof Type.IsBoolean;
+    Call: typeof Type.Call;
+    IsCall: typeof Type.IsCall;
+    Constructor: typeof Type.Constructor;
+    IsConstructor: typeof Type.IsConstructor;
+    Cyclic: typeof Type.Cyclic;
+    IsCyclic: typeof Type.IsCyclic;
+    Enum: typeof Type.Enum;
+    IsEnum: typeof Type.IsEnum;
+    Function: typeof Type.Function;
+    IsFunction: typeof Type.IsFunction;
+    Generic: typeof Type.Generic;
+    IsGeneric: typeof Type.IsGeneric;
+    Identifier: typeof Type.Identifier;
+    IsIdentifier: typeof Type.IsIdentifier;
+    Infer: typeof Type.Infer;
+    IsInfer: typeof Type.IsInfer;
+    Integer: typeof Type.Integer;
+    IsInteger: typeof Type.IsInteger;
+    Intersect: typeof Type.Intersect;
+    IsIntersect: typeof Type.IsIntersect;
+    IsIterator: typeof Type.IsIterator;
+    Iterator: typeof Type.Iterator;
+    IsLiteral: typeof Type.IsLiteral;
+    Literal: typeof Type.Literal;
+    IsNever: typeof Type.IsNever;
+    Never: typeof Type.Never;
+    IsNull: typeof Type.IsNull;
+    Null: typeof Type.Null;
+    IsNumber: typeof Type.IsNumber;
+    Number: typeof Type.Number;
+    IsObject: typeof Type.IsObject;
+    Object: typeof Type.Object;
+    IsParameter: typeof Type.IsParameter;
+    Parameter: typeof Type.Parameter;
+    IsPromise: typeof Type.IsPromise;
+    Promise: typeof Type.Promise;
+    IsRecord: typeof Type.IsRecord;
+    Record: typeof Type.Record;
+    RecordKey: typeof Type.RecordKey;
+    RecordKeyAsPattern: typeof Type.RecordKeyAsPattern;
+    RecordValue: typeof Type.RecordValue;
+    IsRef: typeof Type.IsRef;
+    Ref: typeof Type.Ref;
+    IsRest: typeof Type.IsRest;
+    Rest: typeof Type.Rest;
+    IsKind: typeof Type.IsKind;
+    IsSchema: typeof Type.IsSchema;
+    IsString: typeof Type.IsString;
+    String: typeof Type.String;
+    IsSymbol: typeof Type.IsSymbol;
+    Symbol: typeof Type.Symbol;
+    IsTemplateLiteral: typeof Type.IsTemplateLiteral;
+    TemplateLiteral: typeof Type.TemplateLiteral;
+    IsThis: typeof Type.IsThis;
+    This: typeof Type.This;
+    IsTuple: typeof Type.IsTuple;
+    Tuple: typeof Type.Tuple;
+    IsUndefined: typeof Type.IsUndefined;
+    Undefined: typeof Type.Undefined;
+    IsUnion: typeof Type.IsUnion;
+    Union: typeof Type.Union;
+    IsUnknown: typeof Type.IsUnknown;
+    Unknown: typeof Type.Unknown;
+    IsUnsafe: typeof Type.IsUnsafe;
+    Unsafe: typeof Type.Unsafe;
+    IsVoid: typeof Type.IsVoid;
+    Void: typeof Type.Void;
+};

package/dist/tritio.d.ts

@@ -0,0 +1,23 @@
+import { type RouteSchema, type Context, type MiddlewareHandler, type TritioOptions } from './types';
+export declare class Tritio {
+    private h3;
+    private middlewares;
+    private routes;
+    private prefix;
+    constructor(options?: TritioOptions);
+    use(handler: MiddlewareHandler): this;
+    mount(prefix: string, app: Tritio): this;
+    group(prefix: string, callback: (app: Tritio) => void): this;
+    private joinPaths;
+    private register;
+    get<S extends RouteSchema>(path: string, schema: S, handler: (c: Context<S>) => any): this;
+    post<S extends RouteSchema>(path: string, schema: S, handler: (c: Context<S>) => any): this;
+    put<S extends RouteSchema>(path: string, schema: S, handler: (c: Context<S>) => any): this;
+    delete<S extends RouteSchema>(path: string, schema: S, handler: (c: Context<S>) => any): this;
+    patch<S extends RouteSchema>(path: string, schema: S, handler: (c: Context<S>) => any): this;
+    head<S extends RouteSchema>(path: string, schema: S, handler: (c: Context<S>) => any): this;
+    options<S extends RouteSchema>(path: string, schema: S, handler: (c: Context<S>) => any): this;
+    docs(path?: string): void;
+    get fetch(): (request: Request | string, init?: RequestInit) => Promise<Response>;
+    listen(port: number, callback?: () => void): void;
+}

package/dist/types.d.ts

@@ -0,0 +1,31 @@
+import { type Static, type TSchema } from 'typebox';
+import { H3Event } from 'h3';
+export interface TritioOptions {
+    prefix?: string;
+    cors?: CorsOptions | boolean;
+}
+export interface RouteSchema {
+    body?: TSchema;
+    query?: TSchema;
+    params?: TSchema;
+    response?: TSchema;
+}
+export interface Context<S extends RouteSchema> {
+    event: H3Event;
+    body: S['body'] extends TSchema ? Static<S['body']> : unknown;
+    query: S['query'] extends TSchema ? Static<S['query']> : Record<string, string>;
+    params: S['params'] extends TSchema ? Static<S['params']> : Record<string, string>;
+}
+export interface CorsOptions {
+    origin?: string | string[] | ((origin: string) => boolean);
+    methods?: string[];
+    allowHeaders?: string[];
+    exposeHeaders?: string[];
+    credentials?: boolean;
+    maxAge?: number;
+    preflight?: {
+        statusCode?: number;
+    };
+}
+export type Next = () => Promise<void>;
+export type MiddlewareHandler = (ctx: Context<any>, next: Next) => Promise<void> | void;

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "tritio",
+  "version": "0.1.0",
+  "description": "The fast, opinionated h3 framework",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun && tsc --emitDeclarationOnly --outDir dist"
+  },
+  "dependencies": {
+    "h3": "^2.0.1-rc.8",
+    "typebox": "^1.0.78"
+  }
+}