rmapi-js 10.1.1 → 11.0.0

package/README.md

@@ -35,7 +35,7 @@ const fileEntries = await api.listItems();
 
 // In stateless environments, exchange once and reuse.
 const sessionToken = await auth(token);
-const api = session(sessionToken);
+const sessionApi = session(sessionToken);
 // cache `sessionToken` and reuse it across workers
 ```
 
@@ -62,8 +62,8 @@ Using these apis is a little riskier since they can potentially result in data l
 // upload with custom line height not avilable through reMarkable
 await api.putEpub("name", buffer, { lineHeight: 180 })
 
-// fetch an uploaded pdf, using the hash (from listItems)
-const buffer = await api.getEpub(hash)
+// fetch an uploaded epub, using the id and hash (from listItems)
+const buffer = await api.getEpub(id, hash)
 ```
 
 ### Gotchas

package/dist/error.d.ts

@@ -0,0 +1,14 @@
+/** an error that results from a failed request */
+export declare class ValidationError extends Error {
+    /** the response status number */
+    readonly field: string;
+    /** the response status text */
+    readonly regex: RegExp;
+    constructor(field: string, regex: RegExp, message: string);
+}
+/** an error that results while supplying a hash not found in the entries of the root hash */
+export declare class HashNotFoundError extends Error {
+    /** the hash that couldn't be found */
+    readonly hash: string;
+    constructor(hash: string);
+}

package/dist/error.js

@@ -0,0 +1,21 @@
+/** an error that results from a failed request */
+export class ValidationError extends Error {
+    /** the response status number */
+    field;
+    /** the response status text */
+    regex;
+    constructor(field, regex, message) {
+        super(message);
+        this.field = field;
+        this.regex = regex;
+    }
+}
+/** an error that results while supplying a hash not found in the entries of the root hash */
+export class HashNotFoundError extends Error {
+    /** the hash that couldn't be found */
+    hash;
+    constructor(hash) {
+        super(`'${hash}' not found in the root hash`);
+        this.hash = hash;
+    }
+}

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import { type BackgroundFilter, type CollectionContent, type Content, type DocumentContent, type Metadata, type Orientation, type RawRemarkableApi, type SimpleEntry, type Tag, type TemplateContent, type TextAlignment, type ZoomMode } from "./raw";
-export { HashNotFoundError, ValidationError } from "./error";
-export type { BackgroundFilter, CollectionContent, Content, CPageNumberValue, CPagePage, CPageStringValue, CPages, CPageUUID, DocumentContent, DocumentMetadata, Entries, FileType, KeyboardMetadata, LegacyCollectionContent, LegacyDocumentContent, Metadata, Orientation, PageTag, RawEntry, RawRemarkableApi, SchemaVersion, SimpleEntry, Tag, TemplateContent, TextAlignment, UploadMimeType, ZoomMode, } from "./raw";
+import { type BackgroundFilter, type CollectionContent, type Content, type DocumentContent, type Metadata, type Orientation, type RawRemarkableApi, type SimpleEntry, type Tag, type TemplateContent, type TextAlignment, type ZoomMode } from "./raw.js";
+export { HashNotFoundError, ValidationError } from "./error.js";
+export type { BackgroundFilter, CollectionContent, Content, CPageNumberValue, CPagePage, CPageStringValue, CPages, CPageUUID, DocumentContent, DocumentMetadata, Entries, FileType, KeyboardMetadata, LegacyCollectionContent, LegacyDocumentContent, Metadata, Orientation, PageTag, RawEntry, RawRemarkableApi, SchemaVersion, SimpleEntry, Tag, TemplateContent, TextAlignment, UploadMimeType, ZoomMode, } from "./raw.js";
 /** common properties shared by collections and documents */
 export interface EntryCommon {
     /** the document id, a uuid4 */
@@ -498,12 +498,6 @@ export interface AuthOptions {
 }
 /** options for constructing an api instance from a session token */
 export interface RemarkableSessionOptions {
-    /**
-     * the url for making synchronization requests
-     *
-     * @defaultValue "https://web.eu.tectonic.remarkable.com"
-     */
-    syncHost?: string;
     /**
      * the base url for making upload requests
      *

package/dist/index.js

@@ -17,9 +17,9 @@
  * // persist token
  * const api = await remarkable(token);
  * // list all items (documents and collections)
- * const [first, ...rest] = api.listItems();
+ * const [first, ...rest] = await api.listItems();
  * // rename first item
- * const entry = api.rename(first.hash, "new name");
+ * const entry = await api.rename(first.hash, "new name");
  * ```
  *
  * @example
@@ -52,18 +52,15 @@
  * @packageDocumentation
  */
 import JSZip from "jszip";
-import { nullable, string, values } from "jtd-ts";
 import { v4 as uuid4 } from "uuid";
-import { HashNotFoundError, ValidationError } from "./error";
-import { LruCache } from "./lru";
-import { RawRemarkable, } from "./raw";
-export { HashNotFoundError, ValidationError } from "./error";
+import { z } from "zod";
+import { HashNotFoundError, ValidationError } from "./error.js";
+import { LruCache } from "./lru.js";
+import { RawRemarkable, } from "./raw.js";
+export { HashNotFoundError, ValidationError } from "./error.js";
 const AUTH_HOST = "https://webapp-prod.cloud.remarkable.engineering";
 const RAW_HOST = "https://eu.tectonic.remarkable.com";
 const UPLOAD_HOST = "https://internal.cloud.remarkable.com";
-// ------------ //
-// Request Info //
-// ------------ //
 // The section has all the types that are stored in the remarkable cloud.
 const idReg = /^([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}||trash)$/;
 /** An error that gets thrown when the backend while trying to update
@@ -131,6 +128,7 @@ class Remarkable {
     #cache;
     raw;
     #lastHashGen;
+    #schemaVersion;
     constructor(sessionToken, rawHost, uploadHost, cache) {
         this.#sessionToken = sessionToken;
         this.#cache = cache;
@@ -138,15 +136,16 @@ class Remarkable {
     }
     async #getRootHash(refresh = false) {
         if (refresh || this.#lastHashGen === undefined) {
-            this.#lastHashGen = await this.raw.getRootHash();
+            const [hash, generation, schemaVersion] = await this.raw.getRootHash();
+            this.#lastHashGen = [hash, generation];
+            this.#schemaVersion = schemaVersion;
         }
-        return this.#lastHashGen;
+        return [...this.#lastHashGen, this.#schemaVersion];
     }
     async #putRootHash(hash, generation) {
         try {
             const [rootHash, gen] = await this.raw.putRootHash(hash, generation);
-            const [, , schemaVersion] = this.#lastHashGen; // guaranteed to be set
-            this.#lastHashGen = [rootHash, gen, schemaVersion];
+            this.#lastHashGen = [rootHash, gen];
         }
         catch (ex) {
             // if we hit a generation error, invalidate our cached generation
@@ -186,7 +185,7 @@ class Remarkable {
         if (metaEnt === undefined) {
             throw new Error(`couldn't find metadata for hash ${hash}`);
         }
-        const [{ visibleName, lastModified, pinned, parent, lastOpened, new: isNew, source, }, content,] = await Promise.all([
+        const [{ visibleName, lastModified, pinned, parent, lastOpened, createdTime, new: isNew, source, }, content,] = await Promise.all([
             this.raw.getMetadata(metaEnt.id, metaEnt.hash),
             // collections don't always have content, since content only lists tags
             contentEnt === undefined
@@ -203,6 +202,7 @@ class Remarkable {
                 pinned,
                 source,
                 parent,
+                createdTime,
                 type: "TemplateType",
             };
         }
@@ -336,7 +336,6 @@ class Remarkable {
         const [[contentEntry, uploadContent], [metadataEntry, uploadMetadata], [pagedataEntry, uploadPagedata], [fileEntry, uploadFile], [rootHash, generation, schemaVersion],] = await Promise.all([
             this.raw.putContent(`${id}.content`, content),
             this.raw.putMetadata(`${id}.metadata`, metadata),
-            // eslint-disable-next-line spellcheck/spell-checker
             this.raw.putText(`${id}.pagedata`, "\n"),
             this.raw.putFile(`${id}.${fileType}`, buffer),
             this.#getRootHash(refresh),
@@ -562,8 +561,9 @@ class Remarkable {
     }
     async pruneCache(refresh) {
         const [rootHash] = await this.#getRootHash(refresh);
-        // the keys to delete, we'll drop every key we can currently reach
+        // start by assuming every cached hash is unreachable, then keep the ones we reach
         const toDelete = new Set(this.#cache.keys());
+        toDelete.delete(rootHash);
         // bfs through entries (to semi-optimize promise waiting, although this
         // should only go one step) to track all hashes encountered
         // NOTE that we could increase the cache in this process, or it's possible
@@ -573,9 +573,9 @@ class Remarkable {
         let nextEntries = [];
         while (entries.length) {
             for (const entryList of entries) {
-                for (const { hash, type, id } of entryList) {
-                    toDelete.add(hash);
-                    if (type === 80000000) {
+                for (const { hash, subfiles, id } of entryList) {
+                    toDelete.delete(hash);
+                    if (subfiles > 0) {
                         nextEntries.push(this.raw.getEntries(`${id}.docSchema`, hash));
                     }
                 }
@@ -588,12 +588,11 @@ class Remarkable {
             this.#cache.delete(key);
         }
     }
-    // finally remove any values we had in the cache initially, but couldn't reach
     clearCache() {
         this.raw.clearCache();
     }
 }
-const cached = values(nullable(string()));
+const cached = z.record(z.string(), z.string().nullable());
 /**
  * Exchange a device token for a session token.
  *
@@ -624,8 +623,9 @@ export async function auth(deviceToken, { authHost = AUTH_HOST } = {}) {
  */
 export function session(sessionToken, { rawHost = RAW_HOST, uploadHost = UPLOAD_HOST, cache, maxCacheSize = Infinity, } = {}) {
     const initCache = JSON.parse(cache ?? "{}");
-    if (cached.guard(initCache)) {
-        const entries = Object.entries(initCache);
+    const parsedCache = cached.safeParse(initCache);
+    if (parsedCache.success) {
+        const entries = Object.entries(parsedCache.data);
         const cacheMap = maxCacheSize === Infinity
             ? new Map(entries)
             : new LruCache(maxCacheSize, entries);
@@ -644,13 +644,12 @@ export function session(sessionToken, { rawHost = RAW_HOST, uploadHost = UPLOAD_
  * @returns an api instance
  */
 export async function remarkable(deviceToken, options = {}) {
-    const { authHost, rawHost, uploadHost, cache, maxCacheSize, syncHost } = options ?? {};
+    const { authHost, rawHost, uploadHost, cache, maxCacheSize } = options ?? {};
     const sessionToken = await auth(deviceToken, { authHost });
     return session(sessionToken, {
         rawHost,
         uploadHost,
         cache,
         maxCacheSize,
-        syncHost,
     });
 }

package/dist/lru.d.ts

@@ -0,0 +1,8 @@
+export declare class LruCache extends Map<string, string | null> {
+    #private;
+    constructor(maxSize: number, entries?: Iterable<[string, string | null]>);
+    get(key: string): string | null | undefined;
+    set(key: string, value: string | null): this;
+    delete(key: string): boolean;
+    clear(): void;
+}

package/dist/lru.js

@@ -0,0 +1,64 @@
+export class LruCache extends Map {
+    #maxSize;
+    #currentSize = 0;
+    constructor(maxSize, entries = []) {
+        super();
+        this.#maxSize = maxSize;
+        for (const [key, value] of entries) {
+            this.set(key, value);
+        }
+    }
+    get(key) {
+        const res = super.get(key);
+        if (res !== undefined) {
+            // update order so key is most recent
+            super.delete(key);
+            super.set(key, res);
+        }
+        return res;
+    }
+    set(key, value) {
+        const existing = super.get(key);
+        if (existing === undefined) {
+            this.#currentSize += key.length; // adding a new key
+        }
+        else if (existing !== null) {
+            this.#currentSize -= existing.length; // removing old value
+        }
+        if (value !== null) {
+            this.#currentSize += value.length;
+        }
+        // delete existing value
+        super.delete(key);
+        // evict down to desired size
+        let entry;
+        while (this.#currentSize > this.#maxSize &&
+            (entry = this.entries().next().value)) {
+            const [oldestKey, oldestValue] = entry;
+            super.delete(oldestKey);
+            this.#currentSize -= oldestKey.length;
+            if (oldestValue !== null) {
+                this.#currentSize -= oldestValue.length;
+            }
+        }
+        // finally insert new key and return
+        super.set(key, value);
+        return this;
+    }
+    delete(key) {
+        const value = super.get(key);
+        if (value === undefined) {
+            return false;
+        }
+        super.delete(key);
+        if (value !== null) {
+            this.#currentSize -= value.length;
+        }
+        this.#currentSize -= key.length;
+        return true;
+    }
+    clear() {
+        super.clear();
+        this.#currentSize = 0;
+    }
+}

package/dist/raw.d.ts

@@ -1,4 +1,3 @@
-import "core-js/proposals/array-buffer-base64";
 /** request types */
 export type RequestMethod = "POST" | "GET" | "PUT" | "DELETE" | "PATCH" | "OPTIONS";
 /** the supported upload mime types */
@@ -560,7 +559,7 @@ export interface RawRemarkableApi {
      *
      * @returns the new list entry and a promise to finish the upload
      */
-    putEntries(id: string, entries: RawEntry[], schemaVersion: SchemaVersion): Promise<[RawEntry, Promise<void>]>;
+    putEntries(id: string, entries: readonly RawEntry[], schemaVersion: SchemaVersion): Promise<[RawEntry, Promise<void>]>;
     /**
      * upload a file to the reMarkable cloud using the simple api
      *
@@ -603,7 +602,7 @@ export declare class RawRemarkable implements RawRemarkableApi {
     putText(id: string, text: string): Promise<[RawEntry, Promise<void>]>;
     putContent(id: string, content: Content): Promise<[RawEntry, Promise<void>]>;
     putMetadata(id: string, metadata: Metadata): Promise<[RawEntry, Promise<void>]>;
-    putEntries(id: string, entries: RawEntry[], schemaVersion: SchemaVersion): Promise<[RawEntry, Promise<void>]>;
+    putEntries(id: string, entries: readonly RawEntry[], schemaVersion: SchemaVersion): Promise<[RawEntry, Promise<void>]>;
     uploadFile(visibleName: string, bytes: Uint8Array, mime: UploadMimeType): Promise<SimpleEntry>;
     dumpCache(): string;
     clearCache(): void;