@mercuryworkshop/scramjet 2.0.0-alpha → 2.0.2-alpha

package/dist/types/client/client.d.ts

@@ -0,0 +1,91 @@
+type ScramjetFrame = any;
+import { BareCompatibleClient, ProxyTransport } from "@mercuryworkshop/proxy-transports";
+import { type URLMeta } from "../shared/rewriters/url";
+import { ScramjetContext } from "../shared";
+import { SingletonBox } from "./singletonbox";
+import { ScramjetConfig } from "../types";
+export type ScramjetClientInit = {
+    context: ScramjetContext;
+    transport: ProxyTransport;
+    sendSetCookie: (url: URL, cookie: string) => Promise<void>;
+    shouldPassthroughWebsocket?: (url: string | URL) => boolean;
+    shouldBlockMessageEvent?: (ev: MessageEvent) => boolean;
+    hookSubcontext: (self: Self, frame?: HTMLIFrameElement) => ScramjetClient;
+};
+type NativeStore = {
+    store: Record<string, any>;
+    call: (target: string, that: any, ...args: any[]) => any;
+    construct: (target: string, ...args: any[]) => any;
+};
+type DescriptorStore = {
+    store: Record<string, PropertyDescriptor>;
+    get: (target: string, that: any) => any;
+    set: (target: string, that: any, value: any) => void;
+};
+export type AnyFunction = Function;
+export type ScramjetModule = {
+    enabled: (client: ScramjetClient) => boolean | undefined;
+    disabled: (client: ScramjetClient, self: typeof globalThis) => void | undefined;
+    order: number | undefined;
+    default: (client: ScramjetClient, self: typeof globalThis) => void;
+};
+export type ProxyCtx = {
+    fn: AnyFunction;
+    this: any;
+    args: any[];
+    newTarget: AnyFunction;
+    return: (r: any) => void;
+    call: () => any;
+};
+export type Proxy = {
+    construct?(ctx: ProxyCtx): any;
+    apply?(ctx: ProxyCtx): any;
+};
+export type TrapCtx<T> = {
+    this: any;
+    get: () => T;
+    set: (v: T) => void;
+};
+export type Trap<T> = {
+    writable?: boolean;
+    value?: any;
+    enumerable?: boolean;
+    configurable?: boolean;
+    get?: (ctx: TrapCtx<T>) => T;
+    set?: (ctx: TrapCtx<T>, v: T) => void;
+};
+export declare class ScramjetClient {
+    global: typeof globalThis;
+    init: ScramjetClientInit;
+    locationProxy: any;
+    serviceWorker: ServiceWorkerContainer;
+    bare: BareCompatibleClient;
+    natives: NativeStore;
+    descriptors: DescriptorStore;
+    wrapfn: (i: any, ...args: any) => any;
+    eventcallbacks: Map<any, [
+        {
+            event: string;
+            originalCallback: AnyFunction;
+            proxiedCallback: AnyFunction;
+        }
+    ]>;
+    meta: URLMeta;
+    box: SingletonBox;
+    context: ScramjetContext;
+    constructor(global: typeof globalThis, init: ScramjetClientInit);
+    get frame(): ScramjetFrame | null;
+    get isSubframe(): boolean;
+    hook(): void;
+    get url(): URL;
+    set url(url: URL | string);
+    Proxy(name: string | string[], handler: Proxy): void;
+    RawProxy(target: any, prop: string, handler: Proxy, debugname?: string): void;
+    Trap<T>(name: string | string[], descriptor: Trap<T>): PropertyDescriptor;
+    RawTrap<T>(target: any, prop: string, descriptor: Trap<T>): PropertyDescriptor;
+    rewriteUrl(url: string | URL): string;
+    unrewriteUrl(url: string | URL): string;
+    flagEnabled(flag: keyof ScramjetConfig["flags"]): boolean;
+    get config(): ScramjetConfig;
+}
+export {};

package/dist/types/client/entry.d.ts

@@ -0,0 +1,5 @@
+export declare const iswindow: boolean;
+export declare const isworker: boolean;
+export declare const issw: boolean;
+export declare const isdedicated: boolean;
+export declare const isshared: boolean;

package/dist/types/client/events.d.ts

@@ -0,0 +1,38 @@
+import { ScramjetClient } from "./index";
+/**
+ * Union type for all Scramjet proxified navigation events.
+ */
+export type ScramjetEvent = NavigateEvent | UrlChangeEvent | ScramjetContextEvent;
+/**
+ * Type map for all Scramjet navigation events with their corresponding event types.
+ */
+export type ScramjetEvents = {
+    navigate: NavigateEvent;
+    urlchange: UrlChangeEvent;
+    contextInit: ScramjetContextEvent;
+};
+/**
+ * Navigation event class fired when Scramjet frame navigates to a new proxified URL.
+ */
+export declare class NavigateEvent extends Event {
+    url: string;
+    type: string;
+    constructor(url: string);
+}
+/**
+ * URL change event class fired when the proxified URL changes in a Scramjet frame.
+ */
+export declare class UrlChangeEvent extends Event {
+    url: string;
+    type: string;
+    constructor(url: string);
+}
+/**
+ * Event class fired when Scramjet initializes in a frame.
+ */
+export declare class ScramjetContextEvent extends Event {
+    window: Self;
+    client: ScramjetClient;
+    type: string;
+    constructor(window: Self, client: ScramjetClient);
+}

package/dist/types/client/helpers.d.ts

@@ -0,0 +1 @@
+export declare function getOwnPropertyDescriptorHandler(target: any, prop: any): TypedPropertyDescriptor<any>;

package/dist/types/client/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./client";
+export * from "./entry";
+export * from "./events";
+export * from "./helpers";
+export * from "./location";
+export * from "./index";
+export * from "./location";

package/dist/types/client/location.d.ts

@@ -0,0 +1,2 @@
+import { ScramjetClient } from "./index";
+export declare function createLocationProxy(client: ScramjetClient, self: typeof globalThis): any;

package/dist/types/client/shared/eval.d.ts

@@ -0,0 +1,3 @@
+import { ScramjetClient } from "../index";
+export default function (client: ScramjetClient, self: Self): void;
+export declare function indirectEval(this: ScramjetClient, strict: boolean, js: any): any;

package/dist/types/client/shared/sourcemaps.d.ts

@@ -0,0 +1,19 @@
+import { ScramjetClient } from "../index";
+declare enum RewriteType {
+    Insert = 0,
+    Replace = 1
+}
+type Rewrite = {
+    start: number;
+} & ({
+    type: RewriteType.Insert;
+    size: number;
+} | {
+    type: RewriteType.Replace;
+    end: number;
+    str: string;
+});
+export type SourceMaps = Record<string, Rewrite[]>;
+export declare const enabled: (client: ScramjetClient) => boolean;
+export default function (client: ScramjetClient, self: Self): void;
+export {};

package/dist/types/client/shared/wrap.d.ts

@@ -0,0 +1,4 @@
+import { ScramjetClient } from "../index";
+export declare function createWrapFn(client: ScramjetClient, self: typeof globalThis): (identifier: any, strict: boolean) => any;
+export declare const order = 4;
+export default function (client: ScramjetClient, self: typeof globalThis): void;

package/dist/types/client/singletonbox.d.ts

@@ -0,0 +1,14 @@
+import { ScramjetClient } from "./client";
+import { SourceMaps } from "./shared/sourcemaps";
+export declare class SingletonBox {
+    ownerclient: ScramjetClient;
+    clients: ScramjetClient[];
+    globals: Map<Self, ScramjetClient>;
+    documents: Map<Document, ScramjetClient>;
+    locations: Map<Location, ScramjetClient>;
+    ctors: Record<string, Function[]>;
+    sourcemaps: SourceMaps;
+    constructor(ownerclient: ScramjetClient);
+    registerClient(client: ScramjetClient, global: Self): void;
+    instanceof(obj: any, name: string): boolean;
+}

package/dist/types/fetch/index.d.ts

@@ -0,0 +1,80 @@
+import { BareCompatibleClient, BareResponse, ProxyTransport, RawHeaders, BareRequestInit } from "@mercuryworkshop/proxy-transports";
+import { type URLMeta } from "../shared/rewriters/url";
+import { ScramjetHeaders } from "../shared/headers";
+import { ScramjetContext } from "../shared";
+import DomHandler from "domhandler";
+export interface ScramjetFetchRequest {
+    rawUrl: URL;
+    destination: RequestDestination;
+    mode: RequestMode;
+    referrer: string;
+    method: string;
+    body: BodyType | null;
+    cache: RequestCache;
+    initialHeaders: ScramjetHeaders;
+    rawClientUrl?: URL;
+}
+export interface ScramjetFetchParsed {
+    url: URL;
+    clientUrl?: URL;
+    meta: URLMeta;
+    scriptType: "module" | "regular";
+}
+export interface ScramjetFetchResponse {
+    body: BodyType;
+    headers: ScramjetHeaders;
+    status: number;
+    statusText: string;
+}
+export type FetchHandlerInit = {
+    transport: ProxyTransport;
+    context: ScramjetContext;
+    crossOriginIsolated?: boolean;
+    sendSetCookie: (url: URL, cookie: string) => Promise<void>;
+    fetchDataUrl(dataUrl: string): Promise<BareResponse>;
+    fetchBlobUrl(blobUrl: string): Promise<BareResponse>;
+};
+export declare class ScramjetFetchHandler extends EventTarget {
+    client: BareCompatibleClient;
+    crossOriginIsolated: boolean;
+    context: ScramjetContext;
+    fetchDataUrl: (dataUrl: string) => Promise<Response>;
+    fetchBlobUrl: (blobUrl: string) => Promise<Response>;
+    sendSetCookie: (url: URL, cookie: string) => Promise<void>;
+    constructor(init: FetchHandlerInit);
+    handleFetch(request: ScramjetFetchRequest): Promise<ScramjetFetchResponse>;
+}
+export declare function parseRequest(request: ScramjetFetchRequest, handler: ScramjetFetchHandler): ScramjetFetchParsed;
+export declare function rewriteHeaders(handler: ScramjetFetchHandler, request: ScramjetFetchRequest, parsed: ScramjetFetchParsed, rawHeaders: RawHeaders): Promise<ScramjetHeaders>;
+type BodyType = string | ArrayBuffer | Blob | ReadableStream<any>;
+export declare class ScramjetHTMLPreRewriteEvent extends Event {
+    handler: DomHandler;
+    context: ScramjetFetchRequest;
+    parsed: ScramjetFetchParsed;
+    constructor(handler: DomHandler, context: ScramjetFetchRequest, parsed: ScramjetFetchParsed);
+}
+export declare class ScramjetHTMLPostRewriteEvent extends Event {
+    handler: DomHandler;
+    context: ScramjetFetchRequest;
+    parsed: ScramjetFetchParsed;
+    constructor(handler: DomHandler, context: ScramjetFetchRequest, parsed: ScramjetFetchParsed);
+}
+export declare class ScramjetResponseEvent extends Event {
+    context: ScramjetFetchRequest;
+    parsed: ScramjetFetchParsed;
+    response: ScramjetFetchResponse;
+    _response?: ScramjetFetchResponse | Promise<ScramjetFetchResponse>;
+    constructor(context: ScramjetFetchRequest, parsed: ScramjetFetchParsed, response: ScramjetFetchResponse);
+    respondWith(response: ScramjetFetchResponse | Promise<ScramjetFetchResponse>): void;
+}
+export declare class ScramjetRequestEvent extends Event {
+    context: ScramjetFetchRequest;
+    url: URL;
+    parsed: ScramjetFetchParsed;
+    init: BareRequestInit;
+    client: BareCompatibleClient;
+    _response?: BareResponse | Promise<BareResponse> | Response | Promise<Response>;
+    constructor(context: ScramjetFetchRequest, url: URL, parsed: ScramjetFetchParsed, init: BareRequestInit, client: BareCompatibleClient);
+    respondWith(response: BareResponse | Promise<BareResponse>): void;
+}
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,9 @@
+import "./global.d";
+import { ScramjetConfig } from "./types";
+export * from "./client";
+export * from "./shared";
+export * from "./symbols";
+export * from "./types";
+export * from "./fetch";
+export declare const defaultConfig: ScramjetConfig;
+export declare const defaultConfigDev: ScramjetConfig;