rmapi-js 10.1.0 → 10.2.0

package/dist/raw.js

@@ -1,172 +1,209 @@
 import CRC32C from "crc-32/crc32c";
-import { boolean, elements, empty, enumeration, float64, int32, nullable, properties, string, timestamp, uint8, uint32, values, } from "jtd-ts";
+import { z } from "zod";
 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(),
-    timestamp: float64(),
-}, undefined, true);
-const pageTag = properties({
-    name: string(),
-    pageId: string(),
-    timestamp: float64(),
-}, undefined, true);
-const documentMetadata = properties(undefined, {
-    authors: elements(string()),
-    title: string(),
-    publicationDate: string(),
-    publisher: string(),
-}, true);
-const cPagePage = properties({
-    id: string(),
-    idx: properties({
-        timestamp: string(),
-        value: string(),
-    }, undefined, true),
-}, {
-    template: properties({
-        timestamp: string(),
-        value: string(),
-    }, undefined, true),
-    redir: properties({
-        timestamp: string(),
-        value: int32(),
-    }, undefined, true),
-    scrollTime: properties({
-        timestamp: string(),
-        value: timestamp(),
-    }, undefined, true),
-    verticalScroll: properties({
-        timestamp: string(),
-        value: float64(),
-    }, undefined, true),
-    deleted: properties({
-        timestamp: string(),
-        value: int32(),
-    }, undefined, true),
-}, true);
-const cPages = properties({
-    lastOpened: properties({
-        timestamp: string(),
-        value: string(),
-    }, undefined, true),
-    original: properties({
-        timestamp: string(),
-        value: int32(),
-    }, undefined, true),
-    pages: elements(cPagePage),
-    uuids: nullable(elements(properties({
-        first: string(),
-        second: uint32(),
-    }, undefined, true))),
-}, undefined, true);
-const collectionContent = properties(undefined, {
-    tags: elements(tag),
-});
-const legacyCollectionContent = properties(undefined, {
-    tags: elements(string()),
-});
+const tag = z
+    .object({
+    name: z.string(),
+    timestamp: z.number(),
+})
+    .passthrough();
+const pageTag = z
+    .object({
+    name: z.string(),
+    pageId: z.string(),
+    timestamp: z.number(),
+})
+    .passthrough();
+const documentMetadata = z
+    .object({
+    authors: z.array(z.string()).optional(),
+    title: z.string().optional(),
+    publicationDate: z.string().optional(),
+    publisher: z.string().optional(),
+})
+    .passthrough();
+const cPagePage = z
+    .object({
+    id: z.string(),
+    idx: z.object({ timestamp: z.string(), value: z.string() }).passthrough(),
+    template: z
+        .object({ timestamp: z.string(), value: z.string() })
+        .passthrough()
+        .optional(),
+    redir: z
+        .object({ timestamp: z.string(), value: z.number().int() })
+        .passthrough()
+        .optional(),
+    scrollTime: z
+        .object({
+        timestamp: z.string(),
+        value: z.string().datetime({ offset: true }),
+    })
+        .passthrough()
+        .optional(),
+    verticalScroll: z
+        .object({ timestamp: z.string(), value: z.number() })
+        .passthrough()
+        .optional(),
+    deleted: z
+        .object({ timestamp: z.string(), value: z.number().int() })
+        .passthrough()
+        .optional(),
+})
+    .passthrough();
+const cPages = z
+    .object({
+    lastOpened: z
+        .object({ timestamp: z.string(), value: z.string() })
+        .passthrough(),
+    original: z
+        .object({ timestamp: z.string(), value: z.number().int() })
+        .passthrough(),
+    pages: z.array(cPagePage),
+    uuids: z
+        .array(z
+        .object({ first: z.string(), second: z.number().int().nonnegative() })
+        .passthrough())
+        .nullable(),
+})
+    .passthrough();
+const collectionContent = z
+    .object({
+    tags: z.array(tag).optional(),
+})
+    .strict();
+const legacyCollectionContent = z
+    .object({
+    tags: z.array(z.string()).optional(),
+})
+    .strict();
 const documentContentRequired = {
-    coverPageNumber: int32(),
+    coverPageNumber: z.number().int(),
     documentMetadata,
-    extraMetadata: values(string()),
-    fileType: enumeration("epub", "notebook", "pdf"),
-    fontName: string(),
-    lineHeight: int32(),
-    orientation: enumeration("portrait", "landscape"),
-    pageCount: uint32(),
-    sizeInBytes: string(),
-    textAlignment: enumeration("", "justify", "left"),
-    textScale: float64(),
+    extraMetadata: z.record(z.string(), z.string()),
+    fileType: z.enum(["epub", "notebook", "pdf"]),
+    fontName: z.string(),
+    lineHeight: z.number().int(),
+    orientation: z.enum(["portrait", "landscape"]),
+    pageCount: z.number().int().nonnegative(),
+    textAlignment: z.enum(["", "justify", "left"]),
+    textScale: z.number(),
 };
 const documentContentOptional = {
-    cPages,
-    customZoomCenterX: float64(),
-    customZoomCenterY: float64(),
-    customZoomOrientation: enumeration("portrait", "landscape"),
-    customZoomPageHeight: float64(),
-    customZoomPageWidth: float64(),
-    customZoomScale: float64(),
-    dummyDocument: boolean(),
-    formatVersion: uint8(),
-    keyboardMetadata: properties({
-        count: uint32(),
-        timestamp: float64(),
-    }, undefined, true),
-    lastOpenedPage: int32(),
-    margins: uint32(),
-    originalPageCount: int32(),
-    pages: nullable(elements(string())),
-    pageTags: elements(pageTag),
-    redirectionPageMap: elements(int32()),
-    transform: properties(undefined, {
-        m11: float64(),
-        m12: float64(),
-        m13: float64(),
-        m21: float64(),
-        m22: float64(),
-        m23: float64(),
-        m31: float64(),
-        m32: float64(),
-        m33: float64(),
-    }, true),
+    cPages: cPages.optional(),
+    customZoomCenterX: z.number().optional(),
+    customZoomCenterY: z.number().optional(),
+    customZoomOrientation: z.enum(["portrait", "landscape"]).optional(),
+    customZoomPageHeight: z.number().optional(),
+    customZoomPageWidth: z.number().optional(),
+    customZoomScale: z.number().optional(),
+    dummyDocument: z.boolean().optional(),
+    formatVersion: z.number().int().nonnegative().optional(),
+    keyboardMetadata: z
+        .object({ count: z.number().int().nonnegative(), timestamp: z.number() })
+        .passthrough()
+        .optional(),
+    lastOpenedPage: z.number().int().optional(),
+    margins: z.number().int().nonnegative().optional(),
+    originalPageCount: z.number().int().optional(),
+    pages: z.array(z.string()).nullable().optional(),
+    pageTags: z.array(pageTag).optional(),
+    redirectionPageMap: z.array(z.number().int()).optional(),
+    sizeInBytes: z.string().optional(),
+    transform: z
+        .object({
+        m11: z.number().optional(),
+        m12: z.number().optional(),
+        m13: z.number().optional(),
+        m21: z.number().optional(),
+        m22: z.number().optional(),
+        m23: z.number().optional(),
+        m31: z.number().optional(),
+        m32: z.number().optional(),
+        m33: z.number().optional(),
+    })
+        .passthrough()
+        .optional(),
     // eslint-disable-next-line spellcheck/spell-checker
-    viewBackgroundFilter: enumeration("off", "fullpage"),
-    zoomMode: enumeration("bestFit", "customFit", "fitToHeight", "fitToWidth"),
+    viewBackgroundFilter: z.enum(["off", "fullpage"]).optional(),
+    zoomMode: z
+        .enum(["bestFit", "customFit", "fitToHeight", "fitToWidth"])
+        .optional(),
 };
-const documentContent = properties(documentContentRequired, {
-    ...documentContentOptional,
-    tags: elements(tag),
-}, true);
-const legacyDocumentContent = properties(documentContentRequired, {
-    ...documentContentOptional,
-    tags: elements(string()),
-}, true);
-const templateContent = properties({
-    name: string(),
-    author: string(),
-    iconData: string(),
-    categories: elements(string()),
-    labels: elements(string()),
-    orientation: enumeration("portrait", "landscape"),
-    templateVersion: string(),
-    supportedScreens: elements(enumeration("rm2", "rmPP")),
-    constants: elements(values(int32())),
-    items: elements(empty()),
-}, {
-    formatVersion: uint8(),
-});
-const metadata = properties({
-    lastModified: string(),
-    parent: string(),
-    pinned: boolean(),
-    type: enumeration("DocumentType", "CollectionType", "TemplateType"),
-    visibleName: string(),
-}, {
-    lastOpened: string(),
-    lastOpenedPage: int32(),
-    createdTime: string(),
-    deleted: boolean(),
-    metadatamodified: boolean(),
-    modified: boolean(),
-    synced: boolean(),
-    version: uint32(),
-}, true);
-const updatedRootHash = properties({
-    hash: string(),
-    generation: float64(),
-}, undefined, true);
-const rootHash = properties({
-    hash: string(),
-    generation: float64(),
-    schemaVersion: uint8(),
-}, undefined, true);
-const NativeSimpleEntry = properties({
-    docID: string(),
-    hash: string(),
-}, undefined, true);
+const commonDocumentContent = z
+    .object({ ...documentContentRequired, ...documentContentOptional })
+    .passthrough();
+const documentContent = commonDocumentContent
+    .extend({ tags: z.array(tag).optional() })
+    .passthrough();
+const legacyDocumentContent = commonDocumentContent
+    .extend({ tags: z.array(z.string()).optional() })
+    .passthrough();
+const templateContent = z
+    .object({
+    name: z.string(),
+    author: z.string(),
+    iconData: z.string(),
+    categories: z.array(z.string()),
+    labels: z.array(z.string()),
+    orientation: z.enum(["portrait", "landscape"]),
+    templateVersion: z.string(),
+    supportedScreens: z.array(z.enum(["rm2", "rmPP"])),
+    constants: z.array(z.record(z.string(), z.number().int())).optional(),
+    items: z.array(z.unknown()),
+    formatVersion: z.number().int().nonnegative().optional(),
+})
+    .strict();
+// content payloads aren't discriminable (legacy/modern differ only by tags
+// element type), so this is an ordered union: the first matching variant wins
+const content = z.union([
+    collectionContent,
+    legacyCollectionContent,
+    templateContent,
+    documentContent,
+    legacyDocumentContent,
+]);
+const metadata = z
+    .object({
+    lastModified: z.string(),
+    parent: z.string(),
+    pinned: z.boolean(),
+    type: z.enum(["DocumentType", "CollectionType", "TemplateType"]),
+    visibleName: z.string(),
+    lastOpened: z.string().optional(),
+    lastOpenedPage: z.number().int().optional(),
+    createdTime: z.string().optional(),
+    deleted: z.boolean().optional(),
+    metadatamodified: z.boolean().optional(),
+    modified: z.boolean().optional(),
+    synced: z.boolean().optional(),
+    version: z.number().int().nonnegative().optional(),
+    new: z.boolean().optional(),
+    source: z.string().optional(),
+})
+    .passthrough();
+const updatedRootHash = z
+    .object({
+    hash: z.string(),
+    generation: z.number(),
+})
+    .passthrough();
+const rootHash = z
+    .object({
+    hash: z.string(),
+    generation: z.number(),
+    schemaVersion: z.number().int().nonnegative(),
+})
+    .passthrough();
+const nativeSimpleEntry = z
+    .object({
+    docID: z.string(),
+    hash: z.string(),
+})
+    .passthrough();
 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
@@ -220,9 +257,7 @@ export class RawRemarkable {
         const res = await this.#authedFetch("GET", `${this.#rawHost}/sync/v4/root`);
         const raw = await res.text();
         const loaded = JSON.parse(raw);
-        if (!rootHash.guardAssert(loaded))
-            throw Error("invalid root hash");
-        const { hash, generation, schemaVersion } = loaded;
+        const { hash, generation, schemaVersion } = rootHash.parse(loaded);
         if (schemaVersion !== 3 && schemaVersion !== 4) {
             throw new Error(`schema version ${schemaVersion} not supported`);
         }
@@ -304,34 +339,12 @@ export class RawRemarkable {
     async getContent(fileName, hash) {
         const raw = await this.getText(fileName, hash);
         const loaded = JSON.parse(raw);
-        // jtd can't verify non-discriminated unions, in this case, we have fileType
-        // defined or not. As a result, we try each, and concatenate the errors at the end
-        const errors = [];
-        for (const [name, valid] of [
-            ["collection", collectionContent],
-            ["legacy collection", legacyCollectionContent],
-            ["template", templateContent],
-            ["document", documentContent],
-            ["legacy document", legacyDocumentContent],
-        ]) {
-            try {
-                if (valid.guardAssert(loaded))
-                    return loaded;
-            }
-            catch (ex) {
-                const msg = ex instanceof Error ? ex.message : "unknown error type";
-                errors.push(`Couldn't validate as ${name} because:\n${msg}`);
-            }
-        }
-        const joined = errors.join("\n\nor\n\n");
-        throw new Error(`invalid content: ${joined}`);
+        return content.parse(loaded);
     }
     async getMetadata(fileName, hash) {
         const raw = await this.getText(fileName, hash);
         const loaded = JSON.parse(raw);
-        if (!metadata.guardAssert(loaded))
-            throw Error("invalid metadata");
-        return loaded;
+        return metadata.parse(loaded);
     }
     async putRootHash(hash, generation, broadcast = true) {
         if (!Number.isSafeInteger(generation)) {
@@ -348,9 +361,7 @@ export class RawRemarkable {
         const resp = await this.#authedFetch("PUT", `${this.#rawHost}/sync/v3/root`, { body });
         const raw = await resp.text();
         const loaded = JSON.parse(raw);
-        if (!updatedRootHash.guardAssert(loaded))
-            throw Error("invalid root hash");
-        const { hash: newHash, generation: newGen } = loaded;
+        const { hash: newHash, generation: newGen } = updatedRootHash.parse(loaded);
         if (Number.isSafeInteger(newGen)) {
             return [newHash, newGen];
         }
@@ -425,14 +436,14 @@ export class RawRemarkable {
         }
         // 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 size = entries.reduce((acc, ent) => acc + ent.size, 0);
+        const sorted = [...entries].sort((a, b) => a.id.localeCompare(b.id));
+        const size = sorted.reduce((acc, ent) => acc + ent.size, 0);
         const records = [`${schemaVersion}\n`];
         if (schemaVersion === 4) {
             const name = id === "root" ? "." : id;
-            records.push(`0:${name}:${entries.length}:${size}\n`);
+            records.push(`0:${name}:${sorted.length}:${size}\n`);
         }
-        for (const { hash, type, id, subfiles, size } of entries) {
+        for (const { hash, type, id, subfiles, size } of sorted) {
             const lineType = schemaVersion === 4 ? 0 : type;
             records.push(`${hash}:${lineType}:${id}:${subfiles}:${size}\n`);
         }
@@ -442,7 +453,7 @@ export class RawRemarkable {
         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) {
+            for (const { hash } of sorted) {
                 hashBuffs.push(Uint8Array.fromHex(hash));
             }
             hash = await digest(concatArrays(hashBuffs));
@@ -458,7 +469,7 @@ export class RawRemarkable {
             id,
             hash,
             type: schemaVersion > 3 ? 0 : 80000000,
-            subfiles: entries.length,
+            subfiles: sorted.length,
             size,
         };
         return [res, this.#putFile(`${id}.docSchema`, hash, entryBuff)];
@@ -477,9 +488,7 @@ export class RawRemarkable {
             },
         });
         const loaded = (await resp.json());
-        if (!NativeSimpleEntry.guardAssert(loaded))
-            throw Error("invalid upload response");
-        const { docID, hash } = loaded;
+        const { docID, hash } = nativeSimpleEntry.parse(loaded);
         return { id: docID, hash };
     }
     dumpCache() {