toiljs 0.0.15 → 0.0.19

package/build/client/runtime.d.ts

@@ -1,31 +0,0 @@
-import { type ComponentType, type ReactNode } from 'react';
-import { type RouteParams } from './match.js';
-export interface RouteDef {
-    readonly pattern: string;
-    readonly load: () => Promise<{
-        default: ComponentType;
-    }>;
-}
-export type LayoutLoader = (() => Promise<{
-    default: ComponentType<{
-        children?: ReactNode;
-    }>;
-}>) | null;
-export type NotFoundLoader = (() => Promise<{
-    default: ComponentType;
-}>) | null;
-export declare function navigate(href: string): void;
-export declare function useParams(): RouteParams;
-export declare function useNavigate(): (href: string) => void;
-export declare function useLocation(): string;
-export declare function Link(props: {
-    href: string;
-    className?: string;
-    children?: ReactNode;
-}): ReactNode;
-export declare function Router(props: {
-    routes: RouteDef[];
-    layout?: LayoutLoader;
-    notFound?: NotFoundLoader;
-}): ReactNode;
-export declare function mount(routes: RouteDef[], layout?: LayoutLoader, notFound?: NotFoundLoader): void;

package/build/client/runtime.js

@@ -1,112 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, lazy, Suspense, useContext, useEffect, useState, } from 'react';
-import { createRoot } from 'react-dom/client';
-import { matchRoute } from './match.js';
-const listeners = new Set();
-export function navigate(href) {
-    window.history.pushState({}, '', href);
-    for (const listener of listeners)
-        listener();
-}
-const ParamsContext = createContext({});
-export function useParams() {
-    return useContext(ParamsContext);
-}
-export function useNavigate() {
-    return navigate;
-}
-export function useLocation() {
-    const [pathname, setPathname] = useState(() => window.location.pathname);
-    useEffect(() => {
-        const update = () => {
-            setPathname(window.location.pathname);
-        };
-        listeners.add(update);
-        window.addEventListener('popstate', update);
-        return () => {
-            listeners.delete(update);
-            window.removeEventListener('popstate', update);
-        };
-    }, []);
-    return pathname;
-}
-export function Link(props) {
-    const { href, className, children } = props;
-    const onClick = (e) => {
-        if (e.defaultPrevented ||
-            e.button !== 0 ||
-            e.metaKey ||
-            e.ctrlKey ||
-            e.shiftKey ||
-            e.altKey)
-            return;
-        e.preventDefault();
-        navigate(href);
-    };
-    return (_jsx("a", { href: href, className: className, onClick: onClick, children: children }));
-}
-const pageCache = new Map();
-function pageComponent(route) {
-    let component = pageCache.get(route);
-    if (!component) {
-        component = lazy(route.load);
-        pageCache.set(route, component);
-    }
-    return component;
-}
-let layoutComponent = null;
-let layoutLoader = null;
-function resolveLayout(loader) {
-    if (layoutLoader !== loader || !layoutComponent) {
-        layoutComponent = lazy(loader);
-        layoutLoader = loader;
-    }
-    return layoutComponent;
-}
-let notFoundComponent = null;
-let notFoundLoader = null;
-function resolveNotFound(loader) {
-    if (notFoundLoader !== loader || !notFoundComponent) {
-        notFoundComponent = lazy(loader);
-        notFoundLoader = loader;
-    }
-    return notFoundComponent;
-}
-export function Router(props) {
-    const { routes, layout = null, notFound = null } = props;
-    const pathname = useLocation();
-    let matched;
-    let params = {};
-    for (const route of routes) {
-        const result = matchRoute(route.pattern, pathname);
-        if (result) {
-            matched = route;
-            params = result;
-            break;
-        }
-    }
-    let page;
-    if (matched) {
-        const Page = pageComponent(matched);
-        page = (_jsx(Suspense, { fallback: null, children: _jsx(Page, {}) }));
-    }
-    else if (notFound) {
-        const NotFound = resolveNotFound(notFound);
-        page = (_jsx(Suspense, { fallback: null, children: _jsx(NotFound, {}) }));
-    }
-    else {
-        page = _jsx("div", { style: { padding: 24, fontFamily: 'system-ui' }, children: "404 \u2014 Not found" });
-    }
-    const withParams = _jsx(ParamsContext.Provider, { value: params, children: page });
-    if (layout) {
-        const Layout = resolveLayout(layout);
-        return (_jsx(Suspense, { fallback: null, children: _jsx(Layout, { children: withParams }) }));
-    }
-    return withParams;
-}
-export function mount(routes, layout = null, notFound = null) {
-    const el = document.getElementById('root');
-    if (!el)
-        throw new Error('toil: #root element not found');
-    createRoot(el).render(_jsx(Router, { routes: routes, layout: layout, notFound: notFound }));
-}

package/build/client/scroll.d.ts

@@ -1,8 +0,0 @@
-export declare function enableManualScrollRestoration(): void;
-export declare function rememberScroll(key: string): void;
-export declare function planScroll(opts: {
-    restoreKey?: string;
-    hash: string;
-    toTop: boolean;
-}): void;
-export declare function applyScroll(): void;

package/build/client/scroll.js

@@ -1,36 +0,0 @@
-const positions = new Map();
-let plan = null;
-export function enableManualScrollRestoration() {
-    if (typeof window !== 'undefined' && 'scrollRestoration' in window.history) {
-        window.history.scrollRestoration = 'manual';
-    }
-}
-export function rememberScroll(key) {
-    positions.set(key, window.scrollY);
-}
-export function planScroll(opts) {
-    plan = {
-        restore: opts.restoreKey !== undefined ? (positions.get(opts.restoreKey) ?? 0) : null,
-        hash: opts.hash,
-        toTop: opts.toTop,
-    };
-}
-export function applyScroll() {
-    const current = plan;
-    plan = null;
-    if (!current)
-        return;
-    if (current.hash) {
-        const el = document.getElementById(decodeURIComponent(current.hash.slice(1)));
-        if (el) {
-            el.scrollIntoView();
-            return;
-        }
-    }
-    if (current.restore !== null) {
-        window.scrollTo(0, current.restore);
-        return;
-    }
-    if (current.toTop)
-        window.scrollTo(0, 0);
-}

package/build/io/BinaryReader.d.ts

@@ -1,44 +0,0 @@
-import type { BufferLike, i16, i32, i64, i8, Selector, u16, u32, u8 } from './types.js';
-export declare class BinaryReader {
-    private buffer;
-    private currentOffset;
-    constructor(bytes: BufferLike);
-    get byteLength(): number;
-    static stringCompare(a: string, b: string): number;
-    static bigintCompare(a: bigint, b: bigint): number;
-    static numberCompare(a: number, b: number): number;
-    setBuffer(bytes: BufferLike): void;
-    length(): number;
-    bytesLeft(): number;
-    readI8(): i8;
-    readI16(be?: boolean): i16;
-    readI32(be?: boolean): i32;
-    readI64(be?: boolean): i64;
-    readU8(): u8;
-    readU16(be?: boolean): u16;
-    readU32(be?: boolean): u32;
-    readU64(be?: boolean): bigint;
-    readU128(be?: boolean): bigint;
-    readU256(be?: boolean): bigint;
-    readI128(be?: boolean): bigint;
-    readBoolean(): boolean;
-    readSelector(): Selector;
-    readBytes(length: u32, zeroStop?: boolean): Uint8Array;
-    readString(length: u32): string;
-    readStringWithLength(be?: boolean): string;
-    readBytesWithLength(maxLength?: number, be?: boolean): Uint8Array;
-    readArrayOfBuffer(be?: boolean): Uint8Array[];
-    readU256Array(be?: boolean): bigint[];
-    readU128Array(be?: boolean): bigint[];
-    readU64Array(be?: boolean): bigint[];
-    readU32Array(be?: boolean): u32[];
-    readU16Array(be?: boolean): u16[];
-    readU8Array(): u8[];
-    readStringArray(be?: boolean): string[];
-    readBytesArray(be?: boolean): Uint8Array[];
-    getOffset(): u16;
-    setOffset(offset: u16): void;
-    verifyEnd(size: number): void;
-    private reverseBytes;
-    private toHexString;
-}

package/build/io/BinaryReader.js

@@ -1,244 +0,0 @@
-import { I128_BYTE_LENGTH, I16_BYTE_LENGTH, I32_BYTE_LENGTH, I64_BYTE_LENGTH, I8_BYTE_LENGTH, U128_BYTE_LENGTH, U16_BYTE_LENGTH, U256_BYTE_LENGTH, U32_BYTE_LENGTH, U64_BYTE_LENGTH, U8_BYTE_LENGTH, } from './lengths.js';
-export class BinaryReader {
-    buffer;
-    currentOffset = 0;
-    constructor(bytes) {
-        this.buffer = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    }
-    get byteLength() {
-        return this.buffer.byteLength;
-    }
-    static stringCompare(a, b) {
-        return a.localeCompare(b);
-    }
-    static bigintCompare(a, b) {
-        if (a < b)
-            return -1;
-        if (a > b)
-            return 1;
-        return 0;
-    }
-    static numberCompare(a, b) {
-        if (a < b)
-            return -1;
-        if (a > b)
-            return 1;
-        return 0;
-    }
-    setBuffer(bytes) {
-        this.buffer = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-        this.currentOffset = 0;
-    }
-    length() {
-        return this.buffer.byteLength;
-    }
-    bytesLeft() {
-        return this.buffer.byteLength - this.currentOffset;
-    }
-    readI8() {
-        this.verifyEnd(this.currentOffset + I8_BYTE_LENGTH);
-        const value = this.buffer.getInt8(this.currentOffset);
-        this.currentOffset += I8_BYTE_LENGTH;
-        return value;
-    }
-    readI16(be = true) {
-        this.verifyEnd(this.currentOffset + I16_BYTE_LENGTH);
-        const value = this.buffer.getInt16(this.currentOffset, !be);
-        this.currentOffset += I16_BYTE_LENGTH;
-        return value;
-    }
-    readI32(be = true) {
-        this.verifyEnd(this.currentOffset + I32_BYTE_LENGTH);
-        const value = this.buffer.getInt32(this.currentOffset, !be);
-        this.currentOffset += I32_BYTE_LENGTH;
-        return value;
-    }
-    readI64(be = true) {
-        this.verifyEnd(this.currentOffset + I64_BYTE_LENGTH);
-        const value = this.buffer.getBigInt64(this.currentOffset, !be);
-        this.currentOffset += I64_BYTE_LENGTH;
-        return value;
-    }
-    readU8() {
-        this.verifyEnd(this.currentOffset + U8_BYTE_LENGTH);
-        const value = this.buffer.getUint8(this.currentOffset);
-        this.currentOffset += U8_BYTE_LENGTH;
-        return value;
-    }
-    readU16(be = true) {
-        this.verifyEnd(this.currentOffset + U16_BYTE_LENGTH);
-        const value = this.buffer.getUint16(this.currentOffset, !be);
-        this.currentOffset += U16_BYTE_LENGTH;
-        return value;
-    }
-    readU32(be = true) {
-        this.verifyEnd(this.currentOffset + U32_BYTE_LENGTH);
-        const value = this.buffer.getUint32(this.currentOffset, !be);
-        this.currentOffset += U32_BYTE_LENGTH;
-        return value;
-    }
-    readU64(be = true) {
-        this.verifyEnd(this.currentOffset + U64_BYTE_LENGTH);
-        const value = this.buffer.getBigUint64(this.currentOffset, !be);
-        this.currentOffset += U64_BYTE_LENGTH;
-        return value;
-    }
-    readU128(be = true) {
-        const raw = this.readBytes(U128_BYTE_LENGTH);
-        let bytes = raw;
-        if (!be) {
-            bytes = this.reverseBytes(raw);
-        }
-        return BigInt('0x' + this.toHexString(bytes));
-    }
-    readU256(be = true) {
-        const raw = this.readBytes(U256_BYTE_LENGTH);
-        let bytes = raw;
-        if (!be) {
-            bytes = this.reverseBytes(raw);
-        }
-        return BigInt('0x' + this.toHexString(bytes));
-    }
-    readI128(be = true) {
-        const raw = this.readBytes(I128_BYTE_LENGTH);
-        let bytes = raw;
-        if (!be) {
-            bytes = this.reverseBytes(raw);
-        }
-        let value = BigInt('0x' + this.toHexString(bytes));
-        const signBitMask = 0x80;
-        if (bytes[0] & signBitMask) {
-            const twoTo128 = BigInt(1) << BigInt(128);
-            value = value - twoTo128;
-        }
-        return value;
-    }
-    readBoolean() {
-        return this.readU8() !== 0;
-    }
-    readSelector() {
-        return this.readU32(true);
-    }
-    readBytes(length, zeroStop = false) {
-        this.verifyEnd(this.currentOffset + length);
-        let bytes = new Uint8Array(length);
-        for (let i = 0; i < length; i++) {
-            const b = this.buffer.getUint8(this.currentOffset++);
-            if (zeroStop && b === 0) {
-                bytes = new Uint8Array(bytes.subarray(0, i));
-                break;
-            }
-            bytes[i] = b;
-        }
-        return bytes;
-    }
-    readString(length) {
-        const textDecoder = new TextDecoder();
-        const bytes = this.readBytes(length, false);
-        return textDecoder.decode(bytes);
-    }
-    readStringWithLength(be = true) {
-        const length = this.readU32(be);
-        return this.readString(length);
-    }
-    readBytesWithLength(maxLength = 0, be = true) {
-        const length = this.readU32(be);
-        if (maxLength > 0 && length > maxLength) {
-            throw new Error('Data length exceeds maximum length.');
-        }
-        return this.readBytes(length);
-    }
-    readArrayOfBuffer(be = true) {
-        const length = this.readU16(be);
-        const result = new Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = this.readBytesWithLength();
-        }
-        return result;
-    }
-    readU256Array(be = true) {
-        const length = this.readU16(be);
-        const result = new Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = this.readU256(be);
-        }
-        return result;
-    }
-    readU128Array(be = true) {
-        const length = this.readU16(be);
-        const result = new Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = this.readU128(be);
-        }
-        return result;
-    }
-    readU64Array(be = true) {
-        const length = this.readU16(be);
-        const result = new Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = this.readU64(be);
-        }
-        return result;
-    }
-    readU32Array(be = true) {
-        const length = this.readU16(be);
-        const result = new Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = this.readU32(be);
-        }
-        return result;
-    }
-    readU16Array(be = true) {
-        const length = this.readU16(be);
-        const result = new Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = this.readU16(be);
-        }
-        return result;
-    }
-    readU8Array() {
-        const length = this.readU16(true);
-        const result = new Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = this.readU8();
-        }
-        return result;
-    }
-    readStringArray(be = true) {
-        const length = this.readU16(be);
-        const result = new Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = this.readStringWithLength(be);
-        }
-        return result;
-    }
-    readBytesArray(be = true) {
-        const length = this.readU16(be);
-        const result = new Array(length);
-        for (let i = 0; i < length; i++) {
-            result[i] = this.readBytesWithLength(0, be);
-        }
-        return result;
-    }
-    getOffset() {
-        return this.currentOffset;
-    }
-    setOffset(offset) {
-        this.currentOffset = offset;
-    }
-    verifyEnd(size) {
-        if (size > this.buffer.byteLength) {
-            throw new Error(`Attempt to read beyond buffer length: requested up to byte offset ${size}, but buffer is only ${this.buffer.byteLength} bytes.`);
-        }
-    }
-    reverseBytes(bytes) {
-        const out = new Uint8Array(bytes.length);
-        for (let i = 0; i < bytes.length; i++) {
-            out[i] = bytes[bytes.length - 1 - i];
-        }
-        return out;
-    }
-    toHexString(bytes) {
-        return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
-    }
-}

package/build/io/BinaryWriter.d.ts

@@ -1,44 +0,0 @@
-import type { i16, i32, i64, i8, Selector, u16, u32, u64, u8 } from './types.js';
-import { BinaryReader } from './BinaryReader.js';
-export declare class BinaryWriter implements Disposable {
-    private currentOffset;
-    private buffer;
-    constructor(length?: number);
-    static estimateArrayOfBufferLength(values: Uint8Array[]): u32;
-    writeU8(value: u8): void;
-    writeU16(value: u16, be?: boolean): void;
-    writeU32(value: u32, be?: boolean): void;
-    writeU64(value: u64, be?: boolean): void;
-    writeI8(value: i8): void;
-    writeI16(value: i16, be?: boolean): void;
-    writeI32(value: i32, be?: boolean): void;
-    writeI64(value: i64, be?: boolean): void;
-    writeSelector(value: Selector): void;
-    writeBoolean(value: boolean): void;
-    writeI128(bigIntValue: bigint, be?: boolean): void;
-    writeU256(bigIntValue: bigint, be?: boolean): void;
-    writeU128(bigIntValue: bigint, be?: boolean): void;
-    writeBytes(value: Uint8Array): void;
-    writeString(value: string): void;
-    writeStringWithLength(value: string): void;
-    getBuffer(clear?: boolean): Uint8Array;
-    reset(): void;
-    toBytesReader(): BinaryReader;
-    getOffset(): u32;
-    setOffset(offset: u32): void;
-    clear(): void;
-    [Symbol.dispose](): void;
-    allocSafe(size: u32): void;
-    writeBytesWithLength(value: Uint8Array): void;
-    writeArrayOfBuffer(values: Uint8Array[], be?: boolean): void;
-    writeU32Array(value: u32[], be?: boolean): void;
-    writeU256Array(value: bigint[], be?: boolean): void;
-    writeU128Array(value: bigint[], be?: boolean): void;
-    writeStringArray(value: string[]): void;
-    writeU16Array(value: u16[], be?: boolean): void;
-    writeU8Array(value: u8[]): void;
-    writeU64Array(value: bigint[], be?: boolean): void;
-    writeBytesArray(value: Uint8Array[]): void;
-    private resize;
-    private getDefaultBuffer;
-}