@substrate-system/crypto-stream 0.0.33

package/dist/transform-stream.cjs

@@ -0,0 +1,159 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transform_stream_exports = {};
+__export(transform_stream_exports, {
+  transformStream: () => transformStream
+});
+module.exports = __toCommonJS(transform_stream_exports);
+function transformStream(sourceReadable, transformer) {
+  let transformedReadable;
+  let done;
+  if (typeof TransformStream !== "undefined") {
+    const transform = new TransformStream(transformer);
+    done = sourceReadable.pipeTo(transform.writable);
+    transformedReadable = transform.readable;
+  } else {
+    let resolveDone;
+    let rejectDone;
+    done = new Promise((resolve, reject) => {
+      resolveDone = resolve;
+      rejectDone = reject;
+    });
+    const transformSource = new TransformStreamSource(
+      sourceReadable,
+      transformer,
+      {
+        resolveDone,
+        rejectDone
+      }
+    );
+    transformedReadable = new ReadableStream(transformSource);
+  }
+  done.catch(() => {
+  });
+  return {
+    readable: transformedReadable,
+    done
+  };
+}
+__name(transformStream, "transformStream");
+class TransformStreamSource {
+  static {
+    __name(this, "TransformStreamSource");
+  }
+  readable;
+  transformer;
+  resolveDone;
+  rejectDone;
+  reader;
+  progressMade;
+  wrappedController;
+  type = "bytes";
+  constructor(readable, transformer, {
+    resolveDone,
+    rejectDone
+  }) {
+    this.readable = readable;
+    this.transformer = transformer;
+    this.resolveDone = resolveDone;
+    this.rejectDone = rejectDone;
+    this.reader = readable.getReader();
+    this.progressMade = false;
+    this.wrappedController = null;
+  }
+  // async start (controller:ReadableStreamController<T>) {
+  async start(controller) {
+    this.wrappedController = {
+      desiredSize: controller.desiredSize,
+      enqueue: /* @__PURE__ */ __name((value) => {
+        this.progressMade = true;
+        controller.enqueue(value);
+      }, "enqueue"),
+      error: /* @__PURE__ */ __name((reason) => {
+        this.progressMade = true;
+        if (!(reason instanceof Error)) {
+          reason = new Error(`stream errored; reason: ${reason}`);
+        }
+        controller.error(reason);
+        this.reader.cancel(reason).catch(() => {
+        });
+        this.rejectDone(reason);
+      }, "error"),
+      terminate: /* @__PURE__ */ __name(() => {
+        this.progressMade = true;
+        controller.close();
+        this.reader.cancel(new Error("stream terminated")).catch(() => {
+        });
+        this.resolveDone();
+      }, "terminate")
+    };
+    if (this.transformer.start) {
+      try {
+        await this.transformer.start(this.wrappedController);
+      } catch (err) {
+        this.rejectDone(err);
+        throw err;
+      }
+    }
+  }
+  async pull(controller) {
+    this.progressMade = false;
+    while (!this.progressMade) {
+      try {
+        const data = await this.reader.read();
+        if (!this.wrappedController) {
+          throw new Error("not this.wrappedController");
+        }
+        if (data.done) {
+          if (this.transformer.flush) {
+            await this.transformer.flush(this.wrappedController);
+          }
+          controller.close();
+          this.resolveDone();
+          return;
+        }
+        if (this.transformer.transform) {
+          await this.transformer.transform(
+            data.value,
+            this.wrappedController
+          );
+        } else {
+          if (!this.wrappedController) {
+            throw new Error("not wrapped controller");
+          }
+          this.wrappedController.enqueue(data.value);
+        }
+      } catch (err) {
+        this.rejectDone(err);
+        this.reader.cancel(err).catch(() => {
+        });
+        throw err;
+      }
+    }
+  }
+  async cancel(reason) {
+    await this.reader.cancel(reason);
+    if (reason instanceof Error) {
+      this.rejectDone(reason);
+    } else {
+      this.rejectDone(new Error(`stream cancelled; reason: ${reason}`));
+    }
+  }
+}

package/dist/util.cjs

@@ -0,0 +1,57 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var util_exports = {};
+__export(util_exports, {
+  asBufferSource: () => asBufferSource,
+  generateSalt: () => generateSalt,
+  joinBufs: () => joinBufs,
+  randomBuf: () => randomBuf
+});
+module.exports = __toCommonJS(util_exports);
+var import_one_webcrypto = require("@substrate-system/one-webcrypto");
+function generateSalt(len) {
+  const salt = new Uint8Array(len);
+  import_one_webcrypto.webcrypto.getRandomValues(salt);
+  return salt;
+}
+__name(generateSalt, "generateSalt");
+function randomBuf(length) {
+  return import_one_webcrypto.webcrypto.getRandomValues(new Uint8Array(length));
+}
+__name(randomBuf, "randomBuf");
+function joinBufs(fst, snd) {
+  const view1 = new Uint8Array(fst);
+  const view2 = new Uint8Array(snd);
+  const joined = new Uint8Array(view1.length + view2.length);
+  joined.set(view1);
+  joined.set(view2, view1.length);
+  return joined;
+}
+__name(joinBufs, "joinBufs");
+function asBufferSource(data) {
+  if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data);
+  }
+  if (data.buffer instanceof ArrayBuffer) {
+    return data;
+  }
+  return new Uint8Array(data);
+}
+__name(asBufferSource, "asBufferSource");

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@substrate-system/crypto-stream",
+  "description": "Streaming encryption for the browser",
+  "type": "module",
+  "version": "0.0.33",
+  "main": "dist/index.js",
+  "files": [
+    "./dist/*"
+  ],
+  "scripts": {
+    "lint": "eslint \"./**/*.{ts,js}\"",
+    "test": "esbuild --format=esm --platform=node --sourcemap --bundle test/index.ts | node --input-type=module | tap-spec",
+    "test:electron": "esbuild --bundle test/index.ts | tape-run | tap-spec",
+    "test-tape-run": "cat test/index.html | tape-run --input=html --static=test | tap-spec",
+    "build": "mkdir -p ./dist && rm -rf ./dist/* && tsc --project tsconfig.build.json",
+    "build:cjs": "esbuild src/*.ts --format=cjs --tsconfig=tsconfig.build.json --keep-names --outdir=./dist --out-extension:.js=.cjs",
+    "start": "vite",
+    "toc": "markdown-toc --maxdepth 3 -i README.md",
+    "build-docs": "typedoc ./src/index.ts",
+    "preversion": "npm run lint",
+    "version": "npm run toc && auto-changelog -p --template keepachangelog --breaking-pattern 'BREAKING CHANGE:' && git add CHANGELOG.md README.md",
+    "postversion": "git push --follow-tags && npm publish",
+    "prepublishOnly": "npm run build && npm run build:cjs"
+  },
+  "dependencies": {
+    "@substrate-system/one-webcrypto": "^1.1.6",
+    "uint8arrays": "^6.1.1"
+  },
+  "devDependencies": {
+    "@preact/preset-vite": "^2.10.5",
+    "@preact/signals": "^2.9.1",
+    "@substrate-system/debug": "^0.9.64",
+    "@substrate-system/tapzero": "^0.10.16",
+    "@typescript-eslint/eslint-plugin": "^8.61.0",
+    "@typescript-eslint/parser": "^8.61.0",
+    "auto-changelog": "^2.6.0",
+    "esbuild": "^0.28.1",
+    "eslint": "^8.57.0",
+    "eslint-config-standard": "^17.1.0",
+    "htm": "^3.1.1",
+    "markdown-toc": "^1.2.0",
+    "postcss-nesting": "^14.0.0",
+    "preact": "^10.29.2",
+    "tap-spec": "^5.0.0",
+    "tape-run": "^11.0.0",
+    "typedoc": "^0.28.19",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.16"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./*": {
+      "import": [
+        "./dist/*.js",
+        "./dist/*"
+      ],
+      "require": [
+        "./dist/*.cjs",
+        "./dist/*"
+      ]
+    }
+  },
+  "author": "nichoth <nichoth@gmail.com> (https://nichoth.com)",
+  "directories": {
+    "example": "example",
+    "test": "test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mycelial-systems/crypto-stream.git"
+  },
+  "keywords": [
+    "cryptography",
+    "encryption",
+    "stream",
+    "browser"
+  ],
+  "bugs": {
+    "url": "https://github.com/mycelial-systems/crypto-stream/issues"
+  },
+  "homepage": "https://github.com/mycelial-systems/crypto-stream",
+  "license": "SEE LICENSE IN LICENSE"
+}