@jgengine/core 0.6.0 → 0.8.0

package/dist/data/devProxy.js

@@ -0,0 +1,38 @@
+function readImportMetaEnv() {
+    try {
+        const meta = import.meta;
+        return meta.env ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+export function parseDevProxyTable(raw) {
+    if (raw === undefined || raw.length === 0)
+        return {};
+    try {
+        const parsed = JSON.parse(raw);
+        if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+            return {};
+        const entries = Object.entries(parsed).filter((entry) => typeof entry[1] === "string");
+        return Object.fromEntries(entries);
+    }
+    catch {
+        return {};
+    }
+}
+export const DEFAULT_DEV_PROXY_PREFIX = "/proxy";
+export function proxiedUrl(target, options = {}) {
+    const env = readImportMetaEnv();
+    const dev = options.dev ?? env.DEV === true;
+    if (!dev)
+        return target;
+    const table = options.table ?? parseDevProxyTable(env.VITE_JGENGINE_DEV_PROXY);
+    const prefix = options.prefix ?? DEFAULT_DEV_PROXY_PREFIX;
+    for (const [routeName, base] of Object.entries(table)) {
+        if (target.startsWith(base)) {
+            return `${prefix}/${routeName}${target.slice(base.length)}`;
+        }
+    }
+    return target;
+}

package/dist/data/fetchJson.d.ts

@@ -0,0 +1,20 @@
+export type FetchImpl = typeof fetch;
+export interface FetchJsonOptions {
+    method?: string;
+    headers?: Record<string, string>;
+    body?: string;
+    signal?: AbortSignal;
+    fetchImpl?: FetchImpl;
+}
+export declare class HttpStatusError extends Error {
+    readonly status: number;
+    readonly statusText: string;
+    readonly url: string;
+    constructor(status: number, statusText: string, url: string);
+}
+export declare class JsonParseError extends Error {
+    readonly url: string;
+    readonly cause: unknown;
+    constructor(url: string, cause: unknown);
+}
+export declare function fetchJson<T>(url: string, options?: FetchJsonOptions): Promise<T>;

package/dist/data/fetchJson.js

@@ -0,0 +1,43 @@
+export class HttpStatusError extends Error {
+    status;
+    statusText;
+    url;
+    constructor(status, statusText, url) {
+        super(`HTTP ${status} ${statusText} for ${url}`);
+        this.name = "HttpStatusError";
+        this.status = status;
+        this.statusText = statusText;
+        this.url = url;
+    }
+}
+export class JsonParseError extends Error {
+    url;
+    cause;
+    constructor(url, cause) {
+        super(`failed to parse JSON response from ${url}`);
+        this.name = "JsonParseError";
+        this.url = url;
+        this.cause = cause;
+    }
+}
+export async function fetchJson(url, options = {}) {
+    const fetchImpl = options.fetchImpl ?? fetch;
+    const response = await fetchImpl(url, {
+        method: options.method,
+        headers: options.headers,
+        body: options.body,
+        signal: options.signal,
+    });
+    if (!response.ok) {
+        throw new HttpStatusError(response.status, response.statusText, url);
+    }
+    const text = await response.text();
+    if (text.length === 0)
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch (cause) {
+        throw new JsonParseError(url, cause);
+    }
+}

package/dist/data/jsonDataSource.d.ts

@@ -0,0 +1,4 @@
+import { type DataSource, type DataSourceOptions } from "./dataSource.js";
+import { type FetchJsonOptions } from "./fetchJson.js";
+export type JsonDataSourceOptions = DataSourceOptions & Omit<FetchJsonOptions, "signal">;
+export declare function createJsonDataSource<T>(url: string, options?: JsonDataSourceOptions): DataSource<T>;

package/dist/data/jsonDataSource.js

@@ -0,0 +1,6 @@
+import { createDataSource } from "./dataSource.js";
+import { fetchJson } from "./fetchJson.js";
+export function createJsonDataSource(url, options = {}) {
+    const { intervalMs, clock, ...fetchOptions } = options;
+    return createDataSource((signal) => fetchJson(url, { ...fetchOptions, signal }), { intervalMs, clock });
+}

package/dist/devtools/devtools.d.ts

@@ -0,0 +1,157 @@
+import { type ChangeSignal } from "../store/changeSignal.js";
+export type DevtoolsControlKind = "slider" | "toggle" | "color" | "select" | "text";
+export interface TunableOptions<T> {
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: readonly T[];
+    label?: string;
+    group?: string;
+    onChange?: (value: T) => void;
+}
+export interface DevtoolsControl {
+    readonly name: string;
+    readonly kind: DevtoolsControlKind;
+    readonly label: string;
+    readonly group: string;
+    readonly initial: unknown;
+    readonly min?: number;
+    readonly max?: number;
+    readonly step?: number;
+    readonly options?: readonly unknown[];
+    read(): unknown;
+    write(value: unknown): void;
+    reset(): void;
+}
+export interface Tunable<T> {
+    readonly name: string;
+    readonly kind: DevtoolsControlKind;
+    readonly initial: T;
+    readonly value: T;
+    set(value: T): void;
+    reset(): void;
+    subscribe(listener: (value: T) => void): () => void;
+}
+export interface FrameStats {
+    fps: number;
+    avgFrameMs: number;
+    p95FrameMs: number;
+    maxFrameMs: number;
+    avgSimMs: number;
+    maxSimMs: number;
+    longFrames: number;
+    samples: number;
+    recentFrameMs: readonly number[];
+}
+export interface RenderSample {
+    drawCalls: number;
+    triangles: number;
+    geometries: number;
+    textures: number;
+}
+export interface LatencyStats {
+    lastMs: number;
+    avgMs: number;
+    minMs: number;
+    maxMs: number;
+    samples: number;
+}
+export type DevtoolsLogLevel = "log" | "info" | "warn" | "error";
+export interface DevtoolsLogEntry {
+    at: number;
+    level: DevtoolsLogLevel;
+    message: string;
+}
+export interface DiscoveredEntry {
+    readonly id: string;
+    readonly table: string;
+    readonly key: string;
+    readonly kind: DevtoolsControlKind;
+    readonly initial: unknown;
+    readonly enabled: boolean;
+    read(): unknown;
+}
+export interface TunableAccessor {
+    initial: unknown;
+    get(): unknown;
+    set(value: unknown): void;
+}
+export interface DevtoolsOverrides {
+    enabled: string[];
+    values: Record<string, unknown>;
+}
+export interface DevtoolsSnapshot {
+    at: number;
+    frame: FrameStats | null;
+    render: RenderSample | null;
+    latency: LatencyStats | null;
+    logs: readonly DevtoolsLogEntry[];
+    probes: Record<string, unknown>;
+    controls: readonly {
+        name: string;
+        kind: DevtoolsControlKind;
+        value: unknown;
+        initial: unknown;
+    }[];
+    discovered: readonly {
+        id: string;
+        kind: DevtoolsControlKind;
+        value: unknown;
+        enabled: boolean;
+    }[];
+}
+export interface Devtools {
+    frame: {
+        record(sample: {
+            frameMs: number;
+            simMs: number;
+        }): void;
+        stats(): FrameStats | null;
+    };
+    render: {
+        record(sample: RenderSample): void;
+        latest(): RenderSample | null;
+    };
+    logs: {
+        push(level: DevtoolsLogLevel, message: string): void;
+        captureConsole(): void;
+        list(): readonly DevtoolsLogEntry[];
+        clear(): void;
+    };
+    latency: {
+        record(ms: number): void;
+        stats(): LatencyStats | null;
+    };
+    controls: {
+        register<T>(name: string, initial: T, options?: TunableOptions<T>): Tunable<T>;
+        list(): readonly DevtoolsControl[];
+        get(name: string): DevtoolsControl | null;
+        remove(name: string): void;
+        resetAll(): void;
+    };
+    discover: {
+        bind(table: string, key: string, accessor: TunableAccessor): void;
+        scanTable(table: string, candidate: unknown): number;
+        scanModule(exports: Record<string, unknown>): number;
+        list(): readonly DiscoveredEntry[];
+        enable(id: string): void;
+        disable(id: string): void;
+        clear(): void;
+    };
+    overrides: {
+        export(): DevtoolsOverrides;
+        apply(overrides: DevtoolsOverrides): void;
+    };
+    probes: {
+        register(name: string, read: () => unknown): () => void;
+        read(): Record<string, unknown>;
+    };
+    signal: ChangeSignal;
+    snapshot(): DevtoolsSnapshot;
+}
+export declare function formatLogMessage(args: readonly unknown[]): string;
+export declare function createDevtools(): Devtools;
+export declare const devtools: Devtools;
+export declare function tunable<T>(name: string, initial: T, options?: TunableOptions<T>): Tunable<T>;
+export declare function snapshotDevtools(): DevtoolsSnapshot;
+export declare function instrumentLatency<T extends object>(target: T, methods: readonly (keyof T)[], record?: (ms: number) => void): T;