chemicaljs 1.5.0 → 1.6.1

package/README.md

@@ -11,6 +11,9 @@ A example with all the components can be found in [`/example-components/`](https
 
 A real world styled example can be found in [`/example-styled/`](https://github.com/chemicaljs/chemical/tree/main/examples/example-styled).
 
+A example with a build command and an external wisp server can be found in [`/example-build/`](https://github.com/chemicaljs/chemical/tree/main/examples/example-build).
+
+
 ### Server
 
 Create a new Node.js project and create a script file for the server.
@@ -73,6 +76,42 @@ chemical.server.listen(port, () => {
 });
 ```
 
+### Build
+
+Want to use Chemical without using a custom wisp and/or rammerhead server or without a server at all?
+
+Using the build command you can clone all needed assets into your build folder (like BareMux, Libcurl, and proxies enabled). Note that UV and Scramjet will need an external wisp server to function if you do not provide your own and Rammerhead will not work without your own Rammerhead server running.
+
+1. Import `ChemicalBuild` and create a new build.
+
+```js
+const build = new ChemicalBuild({
+    path: "dist",
+    default: "uv",
+    uv: true,
+    scramjet: true,
+    rammerhead: false,
+});
+```
+
+2. Use `build.write()` to write into the build path.
+
+3. Use `build.write(true)` to first empty the build path.
+
+Below if a full example of building Chemical.
+
+```js
+const build = new ChemicalBuild({
+    path: "dist",
+    default: "uv",
+    uv: true,
+    scramjet: true,
+    rammerhead: false,
+});
+
+await build.write(true);
+```
+
 ### Client
 
 In your project create a folder to store your static assets. Create an index.html file which will be the homepage of your website.
@@ -250,5 +289,14 @@ Set the second parameter of `chemicalAction` to the `id` of the iframe.
 <iframe controls="my-controls-2" id="my-iframe-2" is="chemical-iframe"></iframe>
 ```
 
+## Future Additions
+
+- Link chemical component
+- Automatically add https:// if needed
+- Search engine option for search
+- Easy tab cloaking
+- Easy about:blank
+- Proxy switcher/searchengine switcher/cloak switcher
+
 ## License
 Chemical Uses the MIT license.

package/dist/baremux/baretypes.d.ts

@@ -0,0 +1,22 @@
+export type BareHeaders = Record<string, string | string[]>;
+export type BareMeta = {};
+export type TransferrableResponse = {
+    body: ReadableStream | ArrayBuffer | Blob | string;
+    headers: BareHeaders;
+    status: number;
+    statusText: string;
+};
+export interface BareTransport {
+    init: () => Promise<void>;
+    ready: boolean;
+    connect: (url: URL, origin: string, protocols: string[], requestHeaders: BareHeaders, onopen: (protocol: string) => void, onmessage: (data: Blob | ArrayBuffer | string) => void, onclose: (code: number, reason: string) => void, onerror: (error: string) => void) => [(data: Blob | ArrayBuffer | string) => void, (code: number, reason: string) => void];
+    request: (remote: URL, method: string, body: BodyInit | null, headers: BareHeaders, signal: AbortSignal | undefined) => Promise<TransferrableResponse>;
+    meta: () => BareMeta;
+}
+export interface BareWebSocketMeta {
+    protocol: string;
+    setCookies: string[];
+}
+export type BareHTTPProtocol = 'blob:' | 'http:' | 'https:' | string;
+export type BareWSProtocol = 'ws:' | 'wss:' | string;
+export declare const maxRedirects = 20;

package/dist/baremux/client.d.ts

@@ -0,0 +1,73 @@
+import { BareHeaders, BareTransport } from './baretypes';
+import { WorkerConnection } from './connection';
+export declare function validProtocol(protocol: string): boolean;
+export type WebSocketImpl = {
+    new (...args: ConstructorParameters<typeof WebSocket>): WebSocket;
+};
+export declare namespace BareWebSocket {
+    type GetReadyStateCallback = () => number;
+    type GetSendErrorCallback = () => Error | undefined;
+    type GetProtocolCallback = () => string;
+    type HeadersType = BareHeaders | Headers | undefined;
+    type HeadersProvider = BareHeaders | (() => BareHeaders | Promise<BareHeaders>);
+    interface Options {
+        /**
+         * A provider of request headers to pass to the remote.
+         * Usually one of `User-Agent`, `Origin`, and `Cookie`
+         * Can be just the headers object or an synchronous/asynchronous function that returns the headers object
+         */
+        headers?: BareWebSocket.HeadersProvider;
+        /**
+         * A hook executed by this function with helper arguments for hooking the readyState property. If a hook isn't provided, bare-client will hook the property on the instance. Hooking it on an instance basis is good for small projects, but ideally the class should be hooked by the user of bare-client.
+         */
+        readyStateHook?: ((socket: WebSocket, getReadyState: BareWebSocket.GetReadyStateCallback) => void) | undefined;
+        /**
+         * A hook executed by this function with helper arguments for determining if the send function should throw an error. If a hook isn't provided, bare-client will hook the function on the instance.
+         */
+        sendErrorHook?: ((socket: WebSocket, getSendError: BareWebSocket.GetSendErrorCallback) => void) | undefined;
+        /**
+         * A hook executed by this function with the URL. If a hook isn't provided, bare-client will hook the URL.
+         */
+        urlHook?: ((socket: WebSocket, url: URL) => void) | undefined;
+        /**
+         * A hook executed by this function with a helper for getting the current fake protocol. If a hook isn't provided, bare-client will hook the protocol.
+         */
+        protocolHook?: ((socket: WebSocket, getProtocol: BareWebSocket.GetProtocolCallback) => void) | undefined;
+        /**
+         * A callback executed by this function with an array of cookies. This is called once the metadata from the server is received.
+         */
+        setCookiesCallback?: ((setCookies: string[]) => void) | undefined;
+        webSocketImpl?: WebSocket;
+    }
+}
+/**
+ * A Response with additional properties.
+ */
+export interface BareResponse extends Response {
+    rawResponse: Response;
+    rawHeaders: BareHeaders;
+}
+/**
+ * A BareResponse with additional properties.
+ */
+export interface BareResponseFetch extends BareResponse {
+    finalURL: string;
+}
+export declare class BareMuxConnection {
+    worker: WorkerConnection;
+    constructor(workerPath: string);
+    getTransport(): Promise<string>;
+    setTransport(path: string, options: any[], transferables?: Transferable[]): Promise<void>;
+    setManualTransport(functionBody: string, options: any[], transferables?: Transferable[]): Promise<void>;
+    setRemoteTransport(transport: BareTransport, name: string): Promise<void>;
+    getInnerPort(): MessagePort | Promise<MessagePort>;
+}
+export declare class BareClient {
+    worker: WorkerConnection;
+    /**
+     * Create a BareClient. Calls to fetch and connect will wait for an implementation to be ready.
+     */
+    constructor(worker?: string | MessagePort);
+    createWebSocket(remote: string | URL, protocols?: string | string[] | undefined, webSocketImpl?: WebSocketImpl, requestHeaders?: BareHeaders, arrayBufferImpl?: ArrayBuffer): WebSocket;
+    fetch(url: string | URL, init?: RequestInit): Promise<BareResponseFetch>;
+}

package/dist/baremux/connection.d.ts

@@ -0,0 +1,43 @@
+import { BareHeaders, TransferrableResponse } from "./baretypes";
+export type WorkerMessage = {
+    type: "fetch" | "websocket" | "set" | "get" | "ping";
+    fetch?: {
+        remote: string;
+        method: string;
+        headers: BareHeaders;
+        body: ReadableStream | ArrayBuffer | undefined;
+    };
+    websocket?: {
+        url: string;
+        origin: string;
+        protocols: string[];
+        requestHeaders: BareHeaders;
+        channel: MessagePort;
+    };
+    client?: {
+        function: string;
+        args: any[];
+    };
+};
+export type WorkerRequest = {
+    message: WorkerMessage;
+    port: MessagePort;
+};
+export type WorkerResponse = {
+    type: "fetch" | "websocket" | "set" | "get" | "pong" | "error";
+    fetch?: TransferrableResponse;
+    name?: string;
+    error?: Error;
+};
+export type BroadcastMessage = {
+    type: "refreshPort";
+};
+export declare function browserSupportsTransferringStreams(): boolean;
+export declare class WorkerConnection {
+    channel: BroadcastChannel;
+    port: MessagePort | Promise<MessagePort>;
+    workerPath: string;
+    constructor(worker?: string | MessagePort);
+    createChannel(workerPath?: string, inInit?: boolean): void;
+    sendMessage(message: WorkerMessage, transferable?: Transferable[]): Promise<WorkerResponse>;
+}

package/dist/baremux/index.d.ts

@@ -0,0 +1,9 @@
+export * from './baretypes';
+export * from './client';
+export * from './connection';
+export { BareClient as default } from './client';
+export { WebSocketFields } from "./snapshot";
+export type * from './baretypes';
+export type * from './client';
+export type * from './connection';
+export type * from "./snapshot";