turbo-stream 1.0.4 → 1.1.0

package/dist/flatten.js

@@ -20,7 +20,7 @@ export function flatten(input) {
     return index;
 }
 function stringify(input, index) {
-    const { deferred } = this;
+    const { deferred, plugins } = this;
     const str = this.stringified;
     const partsForObj = (obj) => Object.keys(obj)
         .map((k) => `${JSON.stringify(k)}:${flatten.call(this, obj[k])}`)
@@ -45,51 +45,72 @@ function stringify(input, index) {
                 str[index] = "null";
                 break;
             }
-            let result = Array.isArray(input) ? "[" : "{";
-            if (Array.isArray(input)) {
-                for (let i = 0; i < input.length; i++)
-                    result +=
-                        (i ? "," : "") + (i in input ? flatten.call(this, input[i]) : HOLE);
-                str[index] = result + "]";
-            }
-            else if (input instanceof Date) {
-                str[index] = `["${TYPE_DATE}",${input.getTime()}]`;
-            }
-            else if (input instanceof URL) {
-                str[index] = `["${TYPE_URL}",${JSON.stringify(input.href)}]`;
-            }
-            else if (input instanceof RegExp) {
-                str[index] = `["${TYPE_REGEXP}",${JSON.stringify(input.source)},${JSON.stringify(input.flags)}]`;
-            }
-            else if (input instanceof Set) {
-                str[index] = `["${TYPE_SET}",${[...input]
-                    .map((val) => flatten.call(this, val))
-                    .join(",")}]`;
-            }
-            else if (input instanceof Map) {
-                str[index] = `["${TYPE_MAP}",${[...input]
-                    .flatMap(([k, v]) => [flatten.call(this, k), flatten.call(this, v)])
-                    .join(",")}]`;
-            }
-            else if (input instanceof Promise) {
-                str[index] = `["${TYPE_PROMISE}",${index}]`;
-                deferred[index] = input;
-            }
-            else if (input instanceof Error) {
-                str[index] = `["${TYPE_ERROR}",${JSON.stringify(input.message)}`;
-                if (input.name !== "Error") {
-                    str[index] += `,${JSON.stringify(input.name)}`;
+            const isArray = Array.isArray(input);
+            let pluginHandled = false;
+            if (!isArray && plugins) {
+                for (const plugin of plugins) {
+                    const pluginResult = plugin(input);
+                    if (Array.isArray(pluginResult)) {
+                        pluginHandled = true;
+                        const [pluginIdentifier, ...rest] = pluginResult;
+                        str[index] = `[${JSON.stringify(pluginIdentifier)}`;
+                        if (rest.length > 0) {
+                            str[index] +=
+                                "," + rest.map((v) => flatten.call(this, v)).join(",");
+                        }
+                        str[index] += "]";
+                        break;
+                    }
                 }
-                str[index] += "]";
-            }
-            else if (Object.getPrototypeOf(input) === null) {
-                str[index] = `["${TYPE_NULL_OBJECT}",{${partsForObj(input)}}]`;
             }
-            else if (isPlainObject(input)) {
-                str[index] = `{${partsForObj(input)}}`;
-            }
-            else {
-                throw new Error("Cannot encode object with prototype");
+            if (!pluginHandled) {
+                let result = isArray ? "[" : "{";
+                if (isArray) {
+                    for (let i = 0; i < input.length; i++)
+                        result +=
+                            (i ? "," : "") +
+                                (i in input ? flatten.call(this, input[i]) : HOLE);
+                    str[index] = result + "]";
+                }
+                else if (input instanceof Date) {
+                    str[index] = `["${TYPE_DATE}",${input.getTime()}]`;
+                }
+                else if (input instanceof URL) {
+                    str[index] = `["${TYPE_URL}",${JSON.stringify(input.href)}]`;
+                }
+                else if (input instanceof RegExp) {
+                    str[index] = `["${TYPE_REGEXP}",${JSON.stringify(input.source)},${JSON.stringify(input.flags)}]`;
+                }
+                else if (input instanceof Set) {
+                    str[index] = `["${TYPE_SET}",${[...input]
+                        .map((val) => flatten.call(this, val))
+                        .join(",")}]`;
+                }
+                else if (input instanceof Map) {
+                    str[index] = `["${TYPE_MAP}",${[...input]
+                        .flatMap(([k, v]) => [flatten.call(this, k), flatten.call(this, v)])
+                        .join(",")}]`;
+                }
+                else if (input instanceof Promise) {
+                    str[index] = `["${TYPE_PROMISE}",${index}]`;
+                    deferred[index] = input;
+                }
+                else if (input instanceof Error) {
+                    str[index] = `["${TYPE_ERROR}",${JSON.stringify(input.message)}`;
+                    if (input.name !== "Error") {
+                        str[index] += `,${JSON.stringify(input.name)}`;
+                    }
+                    str[index] += "]";
+                }
+                else if (Object.getPrototypeOf(input) === null) {
+                    str[index] = `["${TYPE_NULL_OBJECT}",{${partsForObj(input)}}]`;
+                }
+                else if (isPlainObject(input)) {
+                    str[index] = `{${partsForObj(input)}}`;
+                }
+                else {
+                    throw new Error("Cannot encode object with prototype");
+                }
             }
             break;
         default:

package/dist/turbo-stream.d.ts

@@ -1,5 +1,6 @@
-export declare function decode(readable: ReadableStream<Uint8Array>): Promise<{
+import { type DecodePlugin, type EncodePlugin } from "./utils.js";
+export declare function decode(readable: ReadableStream<Uint8Array>, plugins?: DecodePlugin[]): Promise<{
     done: Promise<undefined>;
     value: unknown;
 }>;
-export declare function encode(input: unknown): ReadableStream<Uint8Array>;
+export declare function encode(input: unknown, plugins?: EncodePlugin[]): ReadableStream<Uint8Array>;

package/dist/turbo-stream.js

@@ -1,7 +1,7 @@
 import { flatten } from "./flatten.js";
 import { unflatten } from "./unflatten.js";
 import { Deferred, TYPE_ERROR, TYPE_PROMISE, createLineSplittingTransform, } from "./utils.js";
-export async function decode(readable) {
+export async function decode(readable, plugins) {
     const done = new Deferred();
     const reader = readable
         .pipeThrough(createLineSplittingTransform())
@@ -10,6 +10,7 @@ export async function decode(readable) {
         values: [],
         hydrated: [],
         deferred: {},
+        plugins,
     };
     const decoded = await decodeInitial.call(decoder, reader);
     let donePromise = done.promise;
@@ -100,12 +101,13 @@ async function decodeDeferred(reader) {
         read = await reader.read();
     }
 }
-export function encode(input) {
+export function encode(input, plugins) {
     const encoder = {
         deferred: {},
         index: 0,
         indicies: new Map(),
         stringified: [],
+        plugins,
     };
     const textEncoder = new TextEncoder();
     let lastSentIndex = 0;

package/dist/unflatten.js

@@ -16,7 +16,7 @@ export function unflatten(parsed) {
     return hydrate.call(this, startIndex);
 }
 function hydrate(index) {
-    const { hydrated, values, deferred } = this;
+    const { hydrated, values, deferred, plugins } = this;
     switch (index) {
         case UNDEFINED:
             return;
@@ -36,6 +36,14 @@ function hydrate(index) {
         return (hydrated[index] = value);
     if (Array.isArray(value)) {
         if (typeof value[0] === "string") {
+            if (Array.isArray(plugins)) {
+                const args = value.slice(1).map((i) => hydrate.call(this, i));
+                for (const plugin of plugins) {
+                    const result = plugin(value[0], ...args);
+                    if (result)
+                        return (hydrated[index] = result.value);
+                }
+            }
             const [type, b, c] = value;
             switch (type) {
                 case TYPE_DATE:

package/dist/utils.d.ts

@@ -14,16 +14,22 @@ export declare const TYPE_REGEXP = "R";
 export declare const TYPE_SET = "S";
 export declare const TYPE_SYMBOL = "Y";
 export declare const TYPE_URL = "U";
+export type DecodePlugin = (type: string, ...data: unknown[]) => {
+    value: unknown;
+} | false | null | undefined;
+export type EncodePlugin = (value: unknown) => [string, ...unknown[]] | false | null | undefined;
 export interface ThisDecode {
     values: unknown[];
     hydrated: unknown[];
     deferred: Record<number, Deferred<unknown>>;
+    plugins?: DecodePlugin[];
 }
 export interface ThisEncode {
     index: number;
     indicies: Map<unknown, number>;
     stringified: string[];
     deferred: Record<number, Promise<unknown>>;
+    plugins?: EncodePlugin[];
 }
 export declare class Deferred<T = unknown> {
     promise: Promise<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbo-stream",
-  "version": "1.0.4",
+  "version": "1.1.0",
   "description": "A streaming data transport format that aims to support built-in features such as Promises, Dates, RegExps, Maps, Sets and more.",
   "type": "module",
   "files": [