mindoodb-app-sdk 0.0.41 → 0.0.43

package/dist/vite/index.js

@@ -0,0 +1,291 @@
+import {
+  MINDOODB_APP_BUNDLE_ARCHIVE_FILE_NAME,
+  MINDOODB_APP_BUNDLE_MANIFEST_FILE_NAME,
+  MINDOODB_APP_BUNDLE_MANIFEST_FORMAT,
+  MINDOODB_APP_BUNDLE_MANIFEST_VERSION,
+  buildMindooDBAppBundleContentHashInput
+} from "../chunk-LT4FK6LU.js";
+
+// src/vite/index.ts
+import { createHash } from "crypto";
+import { readdir, readFile, writeFile } from "fs/promises";
+import path from "path";
+
+// src/vite/zip.ts
+import { deflateRawSync } from "zlib";
+var CRC32_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let index = 0; index < 256; index += 1) {
+    let value = index;
+    for (let bit = 0; bit < 8; bit += 1) {
+      value = value & 1 ? 3988292384 ^ value >>> 1 : value >>> 1;
+    }
+    table[index] = value >>> 0;
+  }
+  return table;
+})();
+function crc32(data) {
+  let crc = 4294967295;
+  for (let index = 0; index < data.length; index += 1) {
+    crc = CRC32_TABLE[(crc ^ data[index]) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+var DOS_TIME = 0;
+var DOS_DATE = 33;
+var ZIP64_LIMIT = 4294967295;
+var PRECOMPRESSED_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".7z",
+  ".avif",
+  ".br",
+  ".gif",
+  ".gz",
+  ".jpeg",
+  ".jpg",
+  ".mp3",
+  ".mp4",
+  ".ogg",
+  ".png",
+  ".webm",
+  ".webp",
+  ".woff",
+  ".woff2",
+  ".zip",
+  ".zst"
+]);
+function isPrecompressedPath(filePath) {
+  const dotIndex = filePath.lastIndexOf(".");
+  if (dotIndex < 0) {
+    return false;
+  }
+  return PRECOMPRESSED_EXTENSIONS.has(filePath.slice(dotIndex).toLowerCase());
+}
+var LOCAL_HEADER_SIGNATURE = 67324752;
+var CENTRAL_HEADER_SIGNATURE = 33639248;
+var END_OF_CENTRAL_DIRECTORY_SIGNATURE = 101010256;
+var UTF8_NAME_FLAG = 2048;
+function createZipArchive(entries) {
+  const prepared = [];
+  const localChunks = [];
+  let offset = 0;
+  for (const entry of entries) {
+    const nameBytes = Buffer.from(entry.path, "utf8");
+    const data = Buffer.from(entry.data.buffer, entry.data.byteOffset, entry.data.byteLength);
+    const store = isPrecompressedPath(entry.path);
+    const deflated = store ? null : deflateRawSync(data, { level: 9 });
+    const useStored = !deflated || deflated.length >= data.length;
+    const payload = useStored ? data : deflated;
+    if (data.length > ZIP64_LIMIT || payload.length > ZIP64_LIMIT) {
+      throw new Error(`Bundle file "${entry.path}" exceeds the 4 GiB ZIP limit.`);
+    }
+    const header = Buffer.alloc(30);
+    header.writeUInt32LE(LOCAL_HEADER_SIGNATURE, 0);
+    header.writeUInt16LE(20, 4);
+    header.writeUInt16LE(UTF8_NAME_FLAG, 6);
+    header.writeUInt16LE(useStored ? 0 : 8, 8);
+    header.writeUInt16LE(DOS_TIME, 10);
+    header.writeUInt16LE(DOS_DATE, 12);
+    const crc = crc32(data);
+    header.writeUInt32LE(crc, 14);
+    header.writeUInt32LE(payload.length, 18);
+    header.writeUInt32LE(data.length, 22);
+    header.writeUInt16LE(nameBytes.length, 26);
+    header.writeUInt16LE(0, 28);
+    localChunks.push(header, nameBytes, payload);
+    prepared.push({
+      nameBytes,
+      payload,
+      method: useStored ? 0 : 8,
+      crc,
+      uncompressedSize: data.length,
+      localHeaderOffset: offset
+    });
+    offset += header.length + nameBytes.length + payload.length;
+    if (offset > ZIP64_LIMIT) {
+      throw new Error("Bundle archive exceeds the 4 GiB ZIP limit.");
+    }
+  }
+  const centralChunks = [];
+  let centralDirectorySize = 0;
+  for (const entry of prepared) {
+    const header = Buffer.alloc(46);
+    header.writeUInt32LE(CENTRAL_HEADER_SIGNATURE, 0);
+    header.writeUInt16LE(20, 4);
+    header.writeUInt16LE(20, 6);
+    header.writeUInt16LE(UTF8_NAME_FLAG, 8);
+    header.writeUInt16LE(entry.method, 10);
+    header.writeUInt16LE(DOS_TIME, 12);
+    header.writeUInt16LE(DOS_DATE, 14);
+    header.writeUInt32LE(entry.crc, 16);
+    header.writeUInt32LE(entry.payload.length, 20);
+    header.writeUInt32LE(entry.uncompressedSize, 24);
+    header.writeUInt16LE(entry.nameBytes.length, 28);
+    header.writeUInt16LE(0, 30);
+    header.writeUInt16LE(0, 32);
+    header.writeUInt16LE(0, 34);
+    header.writeUInt16LE(0, 36);
+    header.writeUInt32LE(0, 38);
+    header.writeUInt32LE(entry.localHeaderOffset, 42);
+    centralChunks.push(header, entry.nameBytes);
+    centralDirectorySize += header.length + entry.nameBytes.length;
+  }
+  if (prepared.length > 65535) {
+    throw new Error("Bundle archive exceeds the 65535 entry ZIP limit.");
+  }
+  const endRecord = Buffer.alloc(22);
+  endRecord.writeUInt32LE(END_OF_CENTRAL_DIRECTORY_SIGNATURE, 0);
+  endRecord.writeUInt16LE(0, 4);
+  endRecord.writeUInt16LE(0, 6);
+  endRecord.writeUInt16LE(prepared.length, 8);
+  endRecord.writeUInt16LE(prepared.length, 10);
+  endRecord.writeUInt32LE(centralDirectorySize, 12);
+  endRecord.writeUInt32LE(offset, 16);
+  endRecord.writeUInt16LE(0, 20);
+  return Buffer.concat([...localChunks, ...centralChunks, endRecord]);
+}
+
+// src/vite/index.ts
+var DEFAULT_EXCLUDED_ROOT_FILES = /* @__PURE__ */ new Set([
+  "sw.js",
+  "sw.js.map",
+  "registerSW.js",
+  "_headers",
+  "_redirects",
+  MINDOODB_APP_BUNDLE_MANIFEST_FILE_NAME,
+  MINDOODB_APP_BUNDLE_ARCHIVE_FILE_NAME
+]);
+var WORKBOX_RUNTIME_PATTERN = /^workbox-[a-z0-9]+\.js(\.map)?$/i;
+function sha256(data) {
+  return `sha256-${createHash("sha256").update(data).digest("hex")}`;
+}
+async function collectFiles(rootDir) {
+  const collected = [];
+  async function walk(currentDir, prefix) {
+    const entries = await readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) {
+        await walk(path.join(currentDir, entry.name), relativePath);
+      } else if (entry.isFile()) {
+        collected.push(relativePath);
+      }
+    }
+  }
+  await walk(rootDir, "");
+  return collected.sort();
+}
+function isExcluded(relativePath, options) {
+  const isRootLevel = !relativePath.includes("/");
+  if (isRootLevel && DEFAULT_EXCLUDED_ROOT_FILES.has(relativePath)) {
+    return true;
+  }
+  if (isRootLevel && WORKBOX_RUNTIME_PATTERN.test(relativePath)) {
+    return true;
+  }
+  if (options.excludeSourcemaps !== false && relativePath.toLowerCase().endsWith(".map")) {
+    return true;
+  }
+  return options.exclude?.(relativePath) === true;
+}
+function resolveEntryPath(paths, configured) {
+  if (configured) {
+    const normalized = configured.replace(/\\/g, "/").replace(/^\/+/, "");
+    if (!paths.includes(normalized)) {
+      throw new Error(`[haven-bundle] Configured entry "${configured}" is not part of the build output.`);
+    }
+    return normalized;
+  }
+  const preferred = paths.find((candidate) => candidate.toLowerCase() === "index.html");
+  if (preferred) {
+    return preferred;
+  }
+  const nested = paths.find((candidate) => candidate.toLowerCase().endsWith("/index.html"));
+  if (nested) {
+    return nested;
+  }
+  const firstHtml = paths.find((candidate) => candidate.toLowerCase().endsWith(".html"));
+  if (firstHtml) {
+    return firstHtml;
+  }
+  throw new Error("[haven-bundle] The build output does not contain an HTML entry file.");
+}
+async function readPackageMetadata(root) {
+  try {
+    const raw = await readFile(path.join(root, "package.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      name: typeof parsed.name === "string" ? parsed.name : void 0,
+      version: typeof parsed.version === "string" ? parsed.version : void 0
+    };
+  } catch {
+    return { name: void 0, version: void 0 };
+  }
+}
+function havenBundle(options = {}) {
+  let resolvedConfig = null;
+  return {
+    name: "haven-bundle",
+    apply: "build",
+    configResolved(config) {
+      resolvedConfig = config;
+    },
+    async closeBundle() {
+      if (!resolvedConfig) {
+        throw new Error("[haven-bundle] Plugin ran without a resolved Vite config.");
+      }
+      const outDir = path.resolve(resolvedConfig.root, resolvedConfig.build.outDir);
+      const allPaths = await collectFiles(outDir);
+      const bundlePaths = allPaths.filter((candidate) => !isExcluded(candidate, options));
+      if (!bundlePaths.length) {
+        throw new Error(`[haven-bundle] No bundle files found in "${outDir}".`);
+      }
+      const entry = resolveEntryPath(bundlePaths, options.entry);
+      const packageMetadata = await readPackageMetadata(resolvedConfig.root);
+      const appId = options.appId ?? packageMetadata.name;
+      const version = options.version ?? packageMetadata.version;
+      if (!appId) {
+        throw new Error("[haven-bundle] Unable to determine appId \u2014 pass it explicitly.");
+      }
+      if (!version) {
+        throw new Error("[haven-bundle] Unable to determine version \u2014 pass it explicitly.");
+      }
+      const files = [];
+      const archiveEntries = [];
+      for (const relativePath of bundlePaths) {
+        const data = await readFile(path.join(outDir, relativePath));
+        files.push({ path: relativePath, hash: sha256(data), size: data.byteLength });
+        archiveEntries.push({ path: relativePath, data });
+      }
+      const archive = createZipArchive(archiveEntries);
+      const manifest = {
+        format: MINDOODB_APP_BUNDLE_MANIFEST_FORMAT,
+        formatVersion: MINDOODB_APP_BUNDLE_MANIFEST_VERSION,
+        appId,
+        version,
+        entry,
+        archive: {
+          path: MINDOODB_APP_BUNDLE_ARCHIVE_FILE_NAME,
+          hash: sha256(archive),
+          size: archive.byteLength
+        },
+        contentHash: sha256(buildMindooDBAppBundleContentHashInput(files)),
+        generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        files
+      };
+      await writeFile(path.join(outDir, MINDOODB_APP_BUNDLE_ARCHIVE_FILE_NAME), archive);
+      await writeFile(
+        path.join(outDir, MINDOODB_APP_BUNDLE_MANIFEST_FILE_NAME),
+        `${JSON.stringify(manifest, null, 2)}
+`,
+        "utf8"
+      );
+      const totalBytes = files.reduce((sum, file) => sum + file.size, 0);
+      console.log(
+        `[haven-bundle] ${files.length} files (${(totalBytes / 1024 / 1024).toFixed(2)} MB) \u2192 ${MINDOODB_APP_BUNDLE_ARCHIVE_FILE_NAME} (${(archive.byteLength / 1024 / 1024).toFixed(2)} MB), contentHash ${manifest.contentHash.slice(7, 19)}`
+      );
+    }
+  };
+}
+export {
+  havenBundle
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mindoodb-app-sdk",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "engines": {
     "node": ">=22.13.0"
   },
@@ -33,6 +33,11 @@
       "types": "./dist/testing/index.d.ts",
       "import": "./dist/testing/index.js",
       "default": "./dist/testing/index.js"
+    },
+    "./vite": {
+      "types": "./dist/vite/index.d.ts",
+      "import": "./dist/vite/index.js",
+      "default": "./dist/vite/index.js"
     }
   },
   "dependencies": {
@@ -40,7 +45,7 @@
   },
   "peerDependencies": {
     "@automerge/automerge": "^3.3.2",
-    "mindoodb": ">=0.0.57"
+    "mindoodb": ">=0.0.58"
   },
   "peerDependenciesMeta": {
     "@automerge/automerge": {
@@ -52,14 +57,14 @@
   },
   "devDependencies": {
     "@automerge/automerge": "^3.3.2",
-    "mindoodb": "^0.0.57",
+    "mindoodb": "^0.0.58",
     "@types/node": "25.5.0",
     "tsup": "^8.5.1",
     "typescript": "^6.0.2",
     "vitest": "^4.1.2"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/testing/index.ts --format esm --dts --clean --external @automerge/automerge --external mindoodb --tsconfig tsconfig.build.json",
+    "build": "tsup src/index.ts src/testing/index.ts src/vite/index.ts --format esm --dts --clean --external @automerge/automerge --external mindoodb --tsconfig tsconfig.build.json",
     "typecheck": "tsc --noEmit -p tsconfig.json",
     "test": "vitest run",
     "test:watch": "vitest"