rmapi-js 8.4.0 → 9.0.0

package/dist/raw.js

@@ -1,7 +1,8 @@
-import { fromByteArray } from "base64-js";
 import CRC32C from "crc-32/crc32c";
-import { boolean, elements, empty, enumeration, float64, int32, properties, string, timestamp, uint32, uint8, values, } from "jtd-ts";
+import { boolean, elements, empty, enumeration, float64, int32, nullable, properties, string, timestamp, uint8, uint32, values, } from "jtd-ts";
 import { ValidationError } from "./error.js";
+import { concatArrays } from "./utils.js";
+import "core-js/proposals/array-buffer-base64";
 const hashReg = /^[0-9a-f]{64}$/;
 const tag = properties({
     name: string(),
@@ -74,7 +75,7 @@ const documentContent = properties({
     orientation: enumeration("portrait", "landscape"),
     pageCount: uint32(),
     sizeInBytes: string(),
-    textAlignment: enumeration("justify", "left"),
+    textAlignment: enumeration("", "justify", "left"),
     textScale: float64(),
 }, {
     cPages,
@@ -90,10 +91,10 @@ const documentContent = properties({
         count: uint32(),
         timestamp: float64(),
     }, undefined, true),
-    lastOpenedPage: uint32(),
+    lastOpenedPage: int32(),
     margins: uint32(),
     originalPageCount: int32(),
-    pages: elements(string()),
+    pages: nullable(elements(string())),
     pageTags: elements(pageTag),
     redirectionPageMap: elements(int32()),
     tags: elements(tag),
@@ -134,7 +135,7 @@ const metadata = properties({
     visibleName: string(),
 }, {
     lastOpened: string(),
-    lastOpenedPage: uint32(),
+    lastOpenedPage: int32(),
     createdTime: string(),
     deleted: boolean(),
     metadatamodified: boolean(),
@@ -159,9 +160,29 @@ async function digest(buff) {
     const digest = await crypto.subtle.digest("SHA-256", 
     // NOTE this is type hinted wrong, but it does work correctly on a uint8 view
     buff);
-    return [...new Uint8Array(digest)]
-        .map((x) => x.toString(16).padStart(2, "0"))
-        .join("");
+    return new Uint8Array(digest).toHex();
+}
+function parseRawEntryLine(line) {
+    const [hash, type, id, subfiles, size] = line.split(":");
+    if (hash === undefined ||
+        type === undefined ||
+        id === undefined ||
+        subfiles === undefined ||
+        size === undefined) {
+        throw new Error(`line '${line}' was not formatted correctly`);
+    }
+    else if (type === "80000000" || type === "0") {
+        return {
+            hash,
+            type: type === "0" ? 0 : 80000000,
+            id,
+            subfiles: parseInt(subfiles, 10),
+            size: parseInt(size, 10),
+        };
+    }
+    else {
+        throw new Error(`line '${line}' was not formatted correctly`);
+    }
 }
 export class RawRemarkable {
     #authedFetch;
@@ -191,14 +212,14 @@ export class RawRemarkable {
         if (!rootHash.guardAssert(loaded))
             throw Error("invalid root hash");
         const { hash, generation, schemaVersion } = loaded;
-        if (schemaVersion !== 3) {
+        if (schemaVersion !== 3 && schemaVersion !== 4) {
             throw new Error(`schema version ${schemaVersion} not supported`);
         }
         else if (!Number.isSafeInteger(generation)) {
             throw new Error(`generation ${generation} was not a safe integer; please file a bug report`);
         }
         else {
-            return [hash, generation];
+            return [hash, generation, schemaVersion];
         }
     }
     async #getHash(hash) {
@@ -243,41 +264,30 @@ export class RawRemarkable {
     async getEntries(hash) {
         const rawFile = await this.getText(hash);
         const [version, ...rest] = rawFile.slice(0, -1).split("\n");
-        if (version != "3") {
-            throw new Error(`schema version ${version} not supported`);
+        if (version === "3") {
+            return { entries: rest.map(parseRawEntryLine) };
+        }
+        else if (version === "4") {
+            const [info, ...remaining] = rest;
+            if (!info)
+                throw new Error("missing info line for schema version 4");
+            const [lead, id, count, size] = info.split(":");
+            if (lead !== "0" ||
+                id === undefined ||
+                count === undefined ||
+                size === undefined) {
+                throw new Error(`schema 4 info line '${info}' was not formatted correctly`);
+            }
+            const entries = remaining.map(parseRawEntryLine);
+            if (parseInt(count, 10) !== entries.length) {
+                throw new Error(`schema 4 expected ${count} entries, but found ${entries.length}`);
+            }
+            else {
+                return { entries, id, size: parseInt(size, 10) };
+            }
         }
         else {
-            return rest.map((line) => {
-                const [hash, type, id, subfiles, size] = line.split(":");
-                if (hash === undefined ||
-                    type === undefined ||
-                    id === undefined ||
-                    subfiles === undefined ||
-                    size === undefined) {
-                    throw new Error(`line '${line}' was not formatted correctly`);
-                }
-                else if (type === "80000000") {
-                    return {
-                        hash,
-                        type: 80000000,
-                        id,
-                        subfiles: parseInt(subfiles),
-                        size: parseInt(size),
-                    };
-                }
-                else if (type === "0" && subfiles === "0") {
-                    return {
-                        hash,
-                        type: 0,
-                        id,
-                        subfiles: 0,
-                        size: parseInt(size),
-                    };
-                }
-                else {
-                    throw new Error(`line '${line}' was not formatted correctly`);
-                }
-            });
+            throw new Error(`schema version ${version} not supported`);
         }
     }
     async getContent(hash) {
@@ -341,7 +351,7 @@ export class RawRemarkable {
             const crc = CRC32C.buf(bytes, 0);
             const buff = new ArrayBuffer(4);
             new DataView(buff).setInt32(0, crc, false);
-            const crcHash = fromByteArray(new Uint8Array(buff));
+            const crcHash = new Uint8Array(buff).toBase64();
             await this.#authedFetch("PUT", `${this.#rawHost}/sync/v3/files/${hash}`, {
                 body: bytes,
                 headers: {
@@ -396,39 +406,55 @@ export class RawRemarkable {
             return await this.putText(id, JSON.stringify(metadata));
         }
     }
-    async putEntries(id, entries) {
-        // NOTE collections have a special hash function, the hash of their
+    async putEntries(id, entries, schemaVersion) {
+        // NOTE v3 collections have a special hash function, the hash of their
         // contents, so this needs to be different
         entries.sort((a, b) => a.id.localeCompare(b.id));
-        const hashBuff = new Uint8Array(entries.length * 32);
-        for (const [start, { hash }] of entries.entries()) {
-            for (const [i, byte] of (hash.match(/../g) ?? []).entries()) {
-                hashBuff[start * 32 + i] = parseInt(byte, 16);
-            }
-        }
-        const hash = await digest(hashBuff);
         const size = entries.reduce((acc, ent) => acc + ent.size, 0);
-        const records = ["3\n"];
+        const records = [`${schemaVersion}\n`];
+        if (schemaVersion === 4) {
+            const name = id === "root" ? "." : id;
+            records.push(`0:${name}:${entries.length}:${size}\n`);
+        }
         for (const { hash, type, id, subfiles, size } of entries) {
             records.push(`${hash}:${type}:${id}:${subfiles}:${size}\n`);
         }
+        const enc = new TextEncoder();
+        const entryBuff = enc.encode(records.join(""));
+        let hash;
+        if (schemaVersion === 3) {
+            // in schema version 3 an entry's hash is the hash of the concatenated hashes
+            const hashBuffs = [];
+            for (const { hash } of entries) {
+                hashBuffs.push(Uint8Array.fromHex(hash));
+            }
+            hash = await digest(concatArrays(hashBuffs));
+        }
+        else if (schemaVersion === 4) {
+            // in schema version 4 an entry's hash is the hash of the full entry file, same as everything else
+            hash = await digest(entryBuff);
+        }
+        else {
+            throw new Error(`unsupported schema version ${schemaVersion}`);
+        }
         const res = {
             id,
             hash,
-            type: 80000000,
+            type: schemaVersion > 3 ? 0 : 80000000,
             subfiles: entries.length,
             size,
         };
-        const enc = new TextEncoder();
         return [
             res,
             // NOTE when monitoring requests, this had the extension .docSchema appended, but I'm not entirely sure why
-            this.#putFile(hash, `${id}.docSchema`, enc.encode(records.join(""))),
+            this.#putFile(hash, `${id}.docSchema`, entryBuff),
         ];
     }
     async uploadFile(visibleName, bytes, mime) {
         const enc = new TextEncoder();
-        const meta = fromByteArray(enc.encode(JSON.stringify({ file_name: visibleName })));
+        const meta = enc
+            .encode(JSON.stringify({ file_name: visibleName }))
+            .toBase64();
         const resp = await this.#authedFetch("POST", `${this.#uploadHost}/doc/v2/files`, {
             body: bytes,
             headers: {