turbo-stream 0.0.6 → 0.0.8

package/README.md

@@ -18,10 +18,10 @@ npm install turbo-stream
 ```js
 import { decode, encode } from "turbo-stream";
 
-const encodedStream = encode({ answer: Promise.resolve(42) });
+const encodedStream = encode(Promise.resolve(42));
 const decoded = await decode(encodedStream);
-console.log(decoded.value.answer); // a Promise
-console.log(await decoded.value.answer); // 42
+console.log(decoded.value); // a Promise
+console.log(await decoded.value); // 42
 await decoded.done; // wait for the stream to finish
 ```
 

package/dist/flatten.js

@@ -1,4 +1,4 @@
-import { HOLE, NAN, NEGATIVE_INFINITY, NEGATIVE_ZERO, POSITIVE_INFINITY, TYPE_BIGINT, TYPE_DATE, TYPE_MAP, TYPE_PROMISE, TYPE_REGEXP, TYPE_SET, TYPE_SYMBOL, UNDEFINED, } from "./utils.js";
+import { HOLE, NAN, NEGATIVE_INFINITY, NEGATIVE_ZERO, POSITIVE_INFINITY, TYPE_BIGINT, TYPE_DATE, TYPE_ERROR, TYPE_MAP, TYPE_NULL_OBJECT, TYPE_PROMISE, TYPE_REGEXP, TYPE_SET, TYPE_SYMBOL, UNDEFINED, } from "./utils.js";
 export function flatten(input) {
     const existing = this.indicies.get(input);
     if (existing)
@@ -67,6 +67,20 @@ function stringify(input, index) {
                 str[index] = `["${TYPE_PROMISE}",${index}]`;
                 this.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}"`;
+                const parts = [];
+                for (const key in input)
+                    parts.push(`${JSON.stringify(key)}:${flatten.call(this, input[key])}`);
+                str[index] += ",{" + parts.join(",") + "}]";
+            }
             else if (isPlainObject(input)) {
                 const parts = [];
                 for (const key in input)

package/dist/turbo-stream.js

@@ -1,6 +1,6 @@
 import { flatten } from "./flatten.js";
 import { unflatten } from "./unflatten.js";
-import { createLineSplittingTransform, Deferred, TYPE_PROMISE, } from "./utils.js";
+import { createLineSplittingTransform, Deferred, TYPE_PROMISE, TYPE_ERROR, } from "./utils.js";
 export async function decode(readable) {
     const done = new Deferred();
     const reader = readable
@@ -56,7 +56,7 @@ async function decodeDeferred(reader) {
             continue;
         const line = read.value;
         switch (line[0]) {
-            case TYPE_PROMISE:
+            case TYPE_PROMISE: {
                 const colonIndex = line.indexOf(":");
                 const deferredId = Number(line.slice(1, colonIndex));
                 const deferred = this.deferred[deferredId];
@@ -74,9 +74,26 @@ async function decodeDeferred(reader) {
                 const value = unflatten.call(this, jsonLine);
                 deferred.resolve(value);
                 break;
-            // case TYPE_PROMISE_ERROR:
-            //   // TODO: transport promise rejections
-            //   break;
+            }
+            case TYPE_ERROR: {
+                const colonIndex = line.indexOf(":");
+                const deferredId = Number(line.slice(1, colonIndex));
+                const deferred = this.deferred[deferredId];
+                if (!deferred) {
+                    throw new Error(`Deferred ID ${deferredId} not found in stream`);
+                }
+                const lineData = line.slice(colonIndex + 1);
+                let jsonLine;
+                try {
+                    jsonLine = JSON.parse(lineData);
+                }
+                catch (reason) {
+                    throw new SyntaxError();
+                }
+                const value = unflatten.call(this, jsonLine);
+                deferred.reject(value);
+                break;
+            }
             default:
                 throw new SyntaxError();
         }
@@ -94,7 +111,7 @@ export function encode(input) {
     let lastSentIndex = 0;
     const readable = new ReadableStream({
         async start(controller) {
-            const id = flatten.call(encoder, await input);
+            const id = flatten.call(encoder, input);
             if (id < 0) {
                 controller.enqueue(textEncoder.encode(`${id}\n`));
             }
@@ -121,8 +138,22 @@ export function encode(input) {
                             lastSentIndex = encoder.stringified.length - 1;
                         }
                     }, (reason) => {
-                        // TODO: Encode and send errors
-                        throw reason;
+                        if (!reason ||
+                            typeof reason !== "object" ||
+                            !(reason instanceof Error)) {
+                            reason = new Error("An unknown error occurred");
+                        }
+                        const id = flatten.call(encoder, reason);
+                        if (id < 0) {
+                            controller.enqueue(textEncoder.encode(`${TYPE_ERROR}${deferredId}:${id}\n`));
+                        }
+                        else {
+                            const values = encoder.stringified
+                                .slice(lastSentIndex + 1)
+                                .join(",");
+                            controller.enqueue(textEncoder.encode(`${TYPE_ERROR}${deferredId}:[${values}]\n`));
+                            lastSentIndex = encoder.stringified.length - 1;
+                        }
                     })
                         .finally(() => {
                         delete encoder.deferred[Number(deferredId)];

package/dist/unflatten.js

@@ -1,4 +1,9 @@
-import { Deferred, HOLE, NAN, NEGATIVE_INFINITY, NEGATIVE_ZERO, POSITIVE_INFINITY, TYPE_BIGINT, TYPE_DATE, TYPE_MAP, TYPE_PROMISE, TYPE_REGEXP, TYPE_SET, TYPE_SYMBOL, UNDEFINED, } from "./utils.js";
+import { Deferred, HOLE, NAN, NEGATIVE_INFINITY, NEGATIVE_ZERO, POSITIVE_INFINITY, TYPE_BIGINT, TYPE_DATE, TYPE_MAP, TYPE_PROMISE, TYPE_REGEXP, TYPE_SET, TYPE_SYMBOL, UNDEFINED, TYPE_ERROR, TYPE_NULL_OBJECT, } from "./utils.js";
+const globalObj = (typeof window !== "undefined"
+    ? window
+    : typeof globalThis !== "undefined"
+        ? globalThis
+        : undefined);
 export function unflatten(parsed) {
     if (typeof parsed === "number")
         return hydrate.call(this, parsed);
@@ -52,6 +57,13 @@ function hydrate(index) {
                         map.set(hydrate.call(this, value[i]), hydrate.call(this, value[i + 1]));
                     }
                     return map;
+                case TYPE_NULL_OBJECT:
+                    console.log({ value });
+                    const obj = Object.create(null);
+                    hydrated[index] = obj;
+                    for (const key in value[1])
+                        obj[key] = hydrate.call(this, value[1][key]);
+                    return obj;
                 case TYPE_PROMISE:
                     if (hydrated[value[1]]) {
                         return (hydrated[index] = hydrated[value[1]]);
@@ -61,6 +73,13 @@ function hydrate(index) {
                         deferred[value[1]] = d;
                         return (hydrated[index] = d.promise);
                     }
+                case TYPE_ERROR:
+                    const [, message, errorType] = value;
+                    let error = errorType && globalObj && globalObj[errorType]
+                        ? new globalObj[errorType](message)
+                        : new Error(message);
+                    hydrated[index] = error;
+                    return error;
                 default:
                     throw new SyntaxError();
             }

package/dist/utils.d.ts

@@ -12,6 +12,7 @@ export declare const TYPE_REGEXP = "R";
 export declare const TYPE_SYMBOL = "Y";
 export declare const TYPE_NULL_OBJECT = "N";
 export declare const TYPE_PROMISE = "P";
+export declare const TYPE_ERROR = "E";
 export interface ThisDecode {
     values: unknown[];
     hydrated: unknown[];

package/dist/utils.js

@@ -12,6 +12,7 @@ export const TYPE_REGEXP = "R";
 export const TYPE_SYMBOL = "Y";
 export const TYPE_NULL_OBJECT = "N";
 export const TYPE_PROMISE = "P";
+export const TYPE_ERROR = "E";
 export class Deferred {
     promise;
     resolve;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbo-stream",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "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": [