@hyperfixi/core 2.0.0

package/dist/registry/browser-types.mjs

@@ -0,0 +1,76 @@
+function isBrowserPayload(payload) {
+    return (typeof window !== 'undefined' &&
+        typeof document !== 'undefined' &&
+        (payload.target == null || payload.target instanceof Element));
+}
+function isBrowserEventSource(source) {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
+function createDOMEventSource(eventName, options) {
+    const target = options?.target ?? document;
+    const capture = options?.capture ?? false;
+    return {
+        name: eventName,
+        description: options?.description ?? `DOM ${eventName} events`,
+        supportedEvents: [eventName],
+        subscribe(subscribeOptions, context) {
+            const handler = (e) => {
+                const payload = {
+                    type: eventName,
+                    data: e,
+                    target: e.target instanceof Element ? e.target : null,
+                    nativeEvent: e,
+                };
+                subscribeOptions.handler(payload, context);
+            };
+            target.addEventListener(eventName, handler, { capture });
+            return {
+                id: `${eventName}_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+                source: eventName,
+                event: eventName,
+                unsubscribe: () => target.removeEventListener(eventName, handler, { capture }),
+            };
+        },
+        supports(event) {
+            return event === eventName;
+        },
+    };
+}
+function createCustomEventSource(eventName, options) {
+    const target = options?.target ?? document;
+    return {
+        name: eventName,
+        description: options?.description ?? `Custom ${eventName} events`,
+        supportedEvents: [eventName],
+        subscribe(subscribeOptions, context) {
+            const handler = (e) => {
+                const customEvent = e;
+                const payload = {
+                    type: eventName,
+                    data: customEvent.detail,
+                    target: e.target instanceof Element ? e.target : null,
+                    nativeEvent: e,
+                    meta: {
+                        bubbles: customEvent.bubbles,
+                        cancelable: customEvent.cancelable,
+                        composed: customEvent.composed,
+                    },
+                };
+                subscribeOptions.handler(payload, context);
+            };
+            target.addEventListener(eventName, handler);
+            return {
+                id: `${eventName}_${Date.now()}_${Math.random().toString(36).slice(2)}`,
+                source: eventName,
+                event: eventName,
+                unsubscribe: () => target.removeEventListener(eventName, handler),
+            };
+        },
+        supports(event) {
+            return event === eventName;
+        },
+    };
+}
+
+export { createCustomEventSource, createDOMEventSource, isBrowserEventSource, isBrowserPayload };
+//# sourceMappingURL=browser-types.mjs.map

package/dist/registry/context-provider-registry.d.ts

@@ -0,0 +1,38 @@
+import type { ExecutionContext } from '../types/core';
+export type ContextProviderFn<T = unknown> = (context: ExecutionContext) => T | Promise<T>;
+export interface ContextProvider<T = unknown> {
+    readonly name: string;
+    readonly description?: string;
+    readonly provide: ContextProviderFn<T>;
+    readonly cache?: boolean;
+    readonly async?: boolean;
+    readonly dependencies?: string[];
+}
+export interface ContextProviderOptions<T = unknown> {
+    description?: string;
+    cache?: boolean;
+    dependencies?: string[];
+}
+export declare class ContextProviderRegistry {
+    private providers;
+    private globalProviders;
+    register<T>(name: string, provider: ContextProviderFn<T> | ContextProvider<T>, options?: ContextProviderOptions<T>): void;
+    registerGlobal<T>(name: string, provider: ContextProviderFn<T> | ContextProvider<T>, options?: ContextProviderOptions<T>): void;
+    unregister(name: string): boolean;
+    unregisterGlobal(name: string): boolean;
+    get(name: string): ContextProvider | undefined;
+    has(name: string): boolean;
+    resolve<T = unknown>(name: string, context: ExecutionContext, cache?: Map<string, unknown>): Promise<T | undefined>;
+    resolveSync<T = unknown>(name: string, context: ExecutionContext, cache?: Map<string, unknown>): T | undefined;
+    enhance<T extends ExecutionContext>(context: T): T & Record<string, unknown>;
+    resolveAll(context: ExecutionContext): Promise<Record<string, unknown>>;
+    getProviderNames(): string[];
+    clear(): void;
+}
+export declare function createContextProviderRegistry(): ContextProviderRegistry;
+export declare function getDefaultContextProviderRegistry(): ContextProviderRegistry;
+export declare const meProvider: ContextProvider<Element | null>;
+export declare const itProvider: ContextProvider<unknown>;
+export declare const youProvider: ContextProvider<Element | null>;
+export declare const eventProvider: ContextProvider<Event | null | undefined>;
+//# sourceMappingURL=context-provider-registry.d.ts.map

package/dist/registry/environment.d.ts

@@ -0,0 +1,19 @@
+export type RuntimeEnvironment = 'browser' | 'node' | 'universal';
+export type DetectEnvironment<T = typeof globalThis> = T extends {
+    document: any;
+    window: any;
+} ? 'browser' : T extends {
+    process: any;
+    require: any;
+} ? 'node' : 'universal';
+export declare function isBrowserEnvironment(): boolean;
+export declare function isNodeEnvironment(): boolean;
+export declare function getRuntimeEnvironment(): 'browser' | 'node' | 'unknown';
+export declare function assertBrowserEnvironment(): asserts this is {
+    window: Window;
+    document: Document;
+};
+export declare function assertNodeEnvironment(): asserts this is {
+    process: NodeJS.Process;
+};
+//# sourceMappingURL=environment.d.ts.map

package/dist/registry/environment.js

@@ -0,0 +1,36 @@
+'use strict';
+
+function isBrowserEnvironment() {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
+function isNodeEnvironment() {
+    return (typeof process !== 'undefined' && process.versions != null && process.versions.node != null);
+}
+function getRuntimeEnvironment() {
+    if (isBrowserEnvironment())
+        return 'browser';
+    if (isNodeEnvironment())
+        return 'node';
+    return 'unknown';
+}
+function assertBrowserEnvironment() {
+    if (!isBrowserEnvironment()) {
+        throw new Error('This function requires a browser environment with DOM APIs. ' +
+            'Current environment: ' +
+            getRuntimeEnvironment());
+    }
+}
+function assertNodeEnvironment() {
+    if (!isNodeEnvironment()) {
+        throw new Error('This function requires a Node.js environment. ' +
+            'Current environment: ' +
+            getRuntimeEnvironment());
+    }
+}
+
+exports.assertBrowserEnvironment = assertBrowserEnvironment;
+exports.assertNodeEnvironment = assertNodeEnvironment;
+exports.getRuntimeEnvironment = getRuntimeEnvironment;
+exports.isBrowserEnvironment = isBrowserEnvironment;
+exports.isNodeEnvironment = isNodeEnvironment;
+//# sourceMappingURL=environment.js.map

package/dist/registry/environment.mjs

@@ -0,0 +1,30 @@
+function isBrowserEnvironment() {
+    return typeof window !== 'undefined' && typeof document !== 'undefined';
+}
+function isNodeEnvironment() {
+    return (typeof process !== 'undefined' && process.versions != null && process.versions.node != null);
+}
+function getRuntimeEnvironment() {
+    if (isBrowserEnvironment())
+        return 'browser';
+    if (isNodeEnvironment())
+        return 'node';
+    return 'unknown';
+}
+function assertBrowserEnvironment() {
+    if (!isBrowserEnvironment()) {
+        throw new Error('This function requires a browser environment with DOM APIs. ' +
+            'Current environment: ' +
+            getRuntimeEnvironment());
+    }
+}
+function assertNodeEnvironment() {
+    if (!isNodeEnvironment()) {
+        throw new Error('This function requires a Node.js environment. ' +
+            'Current environment: ' +
+            getRuntimeEnvironment());
+    }
+}
+
+export { assertBrowserEnvironment, assertNodeEnvironment, getRuntimeEnvironment, isBrowserEnvironment, isNodeEnvironment };
+//# sourceMappingURL=environment.mjs.map

package/dist/registry/event-source-registry.d.ts

@@ -0,0 +1,54 @@
+import type { ExecutionContext } from '../types/core';
+import type { RuntimeEnvironment } from './environment';
+export type { RuntimeEnvironment } from './environment';
+export type EventTarget<TEnv extends RuntimeEnvironment> = TEnv extends 'browser' ? Element : TEnv extends 'node' ? object : Element | object;
+export type NativeEvent<TEnv extends RuntimeEnvironment> = TEnv extends 'browser' ? Event : TEnv extends 'node' ? never : Event | undefined;
+export interface EventSourcePayload<TEnv extends RuntimeEnvironment = 'universal'> {
+    type: string;
+    data: unknown;
+    target?: EventTarget<TEnv> | null;
+    nativeEvent?: NativeEvent<TEnv>;
+    meta?: Record<string, unknown>;
+}
+export type EventSourceHandler<TEnv extends RuntimeEnvironment = 'universal'> = (payload: EventSourcePayload<TEnv>, context: ExecutionContext) => void;
+export interface EventSourceSubscription {
+    id: string;
+    source: string;
+    event: string;
+    unsubscribe: () => void;
+}
+export interface EventSourceSubscribeOptions {
+    event: string;
+    handler: EventSourceHandler;
+    target?: string | RegExp;
+    selector?: string;
+    options?: Record<string, unknown>;
+}
+export interface EventSource {
+    readonly name: string;
+    readonly description?: string;
+    readonly supportedEvents?: string[];
+    subscribe(options: EventSourceSubscribeOptions, context: ExecutionContext): EventSourceSubscription;
+    supports?(event: string): boolean;
+    initialize?(): Promise<void> | void;
+    destroy?(): void;
+}
+export declare class EventSourceRegistry {
+    private sources;
+    private subscriptions;
+    private nextId;
+    register(name: string, source: EventSource): void;
+    unregister(name: string): boolean;
+    get(name: string): EventSource | undefined;
+    has(name: string): boolean;
+    subscribe(sourceName: string, options: EventSourceSubscribeOptions, context: ExecutionContext): EventSourceSubscription | undefined;
+    unsubscribe(subscriptionId: string): boolean;
+    getSourceNames(): string[];
+    getSubscriptions(): EventSourceSubscription[];
+    findSourceForEvent(event: string): string | undefined;
+    generateId(): string;
+    destroy(): void;
+}
+export declare function createEventSourceRegistry(): EventSourceRegistry;
+export declare function getDefaultEventSourceRegistry(): EventSourceRegistry;
+//# sourceMappingURL=event-source-registry.d.ts.map

package/dist/registry/examples/server-commands.d.ts

@@ -0,0 +1,6 @@
+import type { CommandWithParseInput } from '../../runtime/command-adapter';
+export declare const respondCommand: CommandWithParseInput;
+export declare const redirectCommand: CommandWithParseInput;
+export declare const setHeaderCommand: CommandWithParseInput;
+export declare const serverPlugin: import("../index").LokaScriptPlugin;
+//# sourceMappingURL=server-commands.d.ts.map

package/dist/registry/examples/server-event-source.d.ts

@@ -0,0 +1,32 @@
+import type { EventSource, EventSourcePayload } from '../event-source-registry';
+import type { ExecutionContext } from '../../types/core';
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+export interface ServerRequest {
+    method: HttpMethod;
+    url: string;
+    path: string;
+    query: Record<string, string | string[]>;
+    params: Record<string, string>;
+    headers: Record<string, string | string[]>;
+    body: unknown;
+}
+export interface ServerResponse {
+    status(code: number): ServerResponse;
+    header(name: string, value: string): ServerResponse;
+    json(data: unknown): void;
+    html(content: string): void;
+    text(content: string): void;
+    redirect(url: string, code?: number): void;
+    send(data: unknown): void;
+}
+export interface RequestHandler {
+    method: HttpMethod | '*';
+    pattern: string | RegExp;
+    handler: (payload: EventSourcePayload, context: ExecutionContext) => void;
+}
+export declare function createRequestEventSource(): EventSource & {
+    handleRequest(request: ServerRequest, response: ServerResponse): boolean;
+};
+export declare function createWebSocketEventSource(): EventSource;
+export declare function createSSEEventSource(): EventSource;
+//# sourceMappingURL=server-event-source.d.ts.map

package/dist/registry/index.d.ts

@@ -0,0 +1,54 @@
+export type { ExecutionContext, TypedExecutionContext } from '../types/core';
+export { EventSourceRegistry, createEventSourceRegistry, getDefaultEventSourceRegistry, type EventSource, type EventSourceHandler, type EventSourcePayload, type EventSourceSubscription, type EventSourceSubscribeOptions, } from './event-source-registry';
+export { ContextProviderRegistry, createContextProviderRegistry, getDefaultContextProviderRegistry, type ContextProvider, type ContextProviderFn, type ContextProviderOptions, meProvider, itProvider, youProvider, eventProvider, } from './context-provider-registry';
+export { CommandRegistryV2, CommandAdapterV2, createCommandRegistryV2, type CommandWithParseInput, type RuntimeCommand, } from '../runtime/command-adapter';
+import { CommandRegistryV2 } from '../runtime/command-adapter';
+import { EventSourceRegistry } from './event-source-registry';
+import { ContextProviderRegistry } from './context-provider-registry';
+import type { CommandWithParseInput } from '../runtime/command-adapter';
+import type { EventSource } from './event-source-registry';
+import type { ContextProviderFn, ContextProviderOptions } from './context-provider-registry';
+export interface LokaScriptRegistry {
+    readonly commands: CommandRegistryV2;
+    readonly eventSources: EventSourceRegistry;
+    readonly context: ContextProviderRegistry;
+    use(plugin: LokaScriptPlugin): void;
+    reset(): void;
+}
+export interface LokaScriptPlugin {
+    name: string;
+    version?: string;
+    commands?: CommandWithParseInput[];
+    eventSources?: EventSource[];
+    contextProviders?: Array<{
+        name: string;
+        provide: ContextProviderFn;
+        options?: ContextProviderOptions;
+    }>;
+    setup?(registry: LokaScriptRegistry): void | Promise<void>;
+    teardown?(registry: LokaScriptRegistry): void | Promise<void>;
+}
+export declare function createRegistry(options?: {
+    commands?: CommandRegistryV2;
+    eventSources?: EventSourceRegistry;
+    context?: ContextProviderRegistry;
+}): LokaScriptRegistry;
+export declare function getDefaultRegistry(): LokaScriptRegistry;
+export declare const commands: {
+    register(command: CommandWithParseInput): void;
+    has(name: string): boolean;
+    names(): string[];
+};
+export declare const eventSources: {
+    register(name: string, source: EventSource): void;
+    has(name: string): boolean;
+    names(): string[];
+};
+export declare const context: {
+    register<T>(name: string, provide: ContextProviderFn<T>, options?: ContextProviderOptions<T>): void;
+    has(name: string): boolean;
+    names(): string[];
+};
+export declare function definePlugin(plugin: LokaScriptPlugin): LokaScriptPlugin;
+export { RegistryIntegration, createRegistryIntegration, getDefaultRegistryIntegration, resetDefaultRegistryIntegration, type RegistryIntegrationOptions, } from './runtime-integration';
+//# sourceMappingURL=index.d.ts.map