webuix 0.0.1

package/build.ts

@@ -0,0 +1,16 @@
+Bun.build({
+  entrypoints: ["./src/index.ts", "./src/wrappers/index.ts"],
+  outdir: "./dist",
+  minify: false,
+  target: "browser",
+  format: "cjs",
+  splitting: true,
+  // naming: {
+  //   entry: `[name].bundle.${ext}`,
+  //   chunk: `[name]-[hash].${ext}`,
+  //   asset: "[name]-[hash][ext]",
+  // },
+}).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/dist/index.js

@@ -0,0 +1,2 @@
+// src/index.ts
+console.log("This is a test for Bun's TypeScript support.");

package/dist/wrappers/index.js

@@ -0,0 +1,135 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/wrappers/index.ts
+var exports_wrappers = {};
+__export(exports_wrappers, {
+  wrapToReadableStream: () => wrapToReadableStream,
+  wrapInputStream: () => wrapInputStream
+});
+module.exports = __toCommonJS(exports_wrappers);
+
+// src/wrappers/wrapToReadableStream.ts
+var readableStreamInit = {
+  chunkSize: 1024 * 1024,
+  headers: {
+    "Content-Type": "application/octet-stream"
+  }
+};
+async function wrapToReadableStream(inputStream, init = {}) {
+  const mergedInit = {
+    ...readableStreamInit,
+    ...init
+  };
+  return new Promise((resolve, reject) => {
+    let input;
+    try {
+      input = inputStream;
+      if (!input) {
+        throw new Error("Failed to open file input stream");
+      }
+    } catch (error) {
+      reject(error);
+      return;
+    }
+    const abortHandler = () => {
+      try {
+        input?.close();
+      } catch (error) {
+        console.error("Error during abort cleanup:", error);
+      }
+      reject(new DOMException("The operation was aborted.", "AbortError"));
+    };
+    if (mergedInit.signal) {
+      if (mergedInit.signal.aborted) {
+        abortHandler();
+        return;
+      }
+      mergedInit.signal.addEventListener("abort", abortHandler);
+    }
+    const stream = new ReadableStream({
+      async pull(controller) {
+        try {
+          const chunkData = getChunkData(input, mergedInit.chunkSize);
+          if (!chunkData) {
+            controller.close();
+            cleanup();
+            return;
+          }
+          controller.enqueue(chunkData);
+        } catch (error) {
+          cleanup();
+          controller.error(error);
+          reject(new Error(`Error reading file chunk: ${error}`));
+        }
+      },
+      cancel(reason) {
+        console.warn("Stream canceled:", reason);
+        cleanup();
+      }
+    });
+    function cleanup() {
+      try {
+        if (mergedInit.signal) {
+          mergedInit.signal.removeEventListener("abort", abortHandler);
+        }
+        input?.close();
+      } catch (error) {
+        console.error(`Error during cleanup: ${error}`);
+      }
+    }
+    resolve(stream);
+  });
+}
+function getChunkData(input, chunkSize) {
+  try {
+    const chunkData = chunkSize ? input.readChunk(chunkSize) : input.read();
+    if (typeof chunkData === "number") {
+      return new Uint8Array([chunkData]);
+    } else if (typeof chunkData === "string") {
+      const chunk = JSON.parse(chunkData);
+      return chunk && Array.isArray(chunk) && chunk.length > 0 ? new Uint8Array(chunk) : null;
+    }
+    return null;
+  } catch (error) {
+    throw new Error("Error reading chunk data: " + error);
+  }
+}
+// src/wrappers/wrapInputStream.ts
+async function wrapInputStream(inputStream, init = {}) {
+  const mergedInit = {
+    ...readableStreamInit,
+    ...init
+  };
+  try {
+    const stream = await wrapToReadableStream(inputStream, mergedInit);
+    return new Response(stream, mergedInit);
+  } catch (error) {
+    throw new Error(`wrapInputStream failed: ${error}`);
+  }
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "webuix",
+  "version": "0.0.1",
+  "type": "module",
+  "description": "A library to make your life easier when working with MMRL's WebUI",
+  "source": "src/index.ts",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.esm.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "bun run build.ts",
+    "upload": "npm run build && npm publish"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "GPL-3.0-only",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}