rmapi-js 10.1.0 → 10.2.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/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,12 +52,12 @@
  * @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";
@@ -131,6 +131,7 @@ class Remarkable {
     #cache;
     raw;
     #lastHashGen;
+    #schemaVersion;
     constructor(sessionToken, rawHost, uploadHost, cache) {
         this.#sessionToken = sessionToken;
         this.#cache = cache;
@@ -138,15 +139,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 +188,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 +205,7 @@ class Remarkable {
                 pinned,
                 source,
                 parent,
+                createdTime,
                 type: "TemplateType",
             };
         }
@@ -562,8 +565,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 +577,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 +592,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 +627,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 +648,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/raw.d.ts

@@ -216,7 +216,7 @@ export interface CommonDocumentContent {
     /** a mapping from page number to page id in pages */
     redirectionPageMap?: number[];
     /** ostensibly the size in bytes of the file, but this differs from other measurements */
-    sizeInBytes: string;
+    sizeInBytes?: string;
     /** text alignment for this document */
     textAlignment: TextAlignment;
     /**
@@ -560,7 +560,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 +603,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;