@kisaragi-hiu/cached-fetch 0.2.0 → 0.3.4

package/README.md

@@ -17,34 +17,29 @@ const text = await cached(
 
 This persists the text response in `os.tmpdir` and should stay around until the next reboot.
 
-Arguments:
-
-```typescript
-/**
- * The key of the value.
- * Subsequent calls with the same key will return the cached value.
- */
-key: string,
-/**
- * A fetcher function, called when the value isn't cached.
- *
- * Should return a promise, which resolves to an object whose text key is a
- * Promise<string> --- usually a Response, but the ProcessPromise from the
- * zx library are also supported.
- */
-fetcher: () => Promise<{ text: () => Promise<string> }>
-```
+Signature: `cached(key, fetcher)`
 
-## Bonus usage
-
-This also works:
-
-```typescript
-import { $ } from "zx";
-import { cached } from "@kisaragi-hiu/cached-fetch";
+Arguments:
 
-const text = await cached(
-  "myCacheKey",
-  () => $`sleep 1 && echo "demo for a slow process"`
-)
-```
+- `key`: the key of the value. Subsequent calls with the same key will return the cached value.
+- `fetcher`: a function doing work that should be cached. This should return any of these:
+  - `Promise<{text: () => string | Promise<string>}`, a promise of an object whose “text” property is a function returning a string or a promise of a string.
+    
+    This covers both a `Promise<Response>` from `fetch`, and also `ProcessPromise` from `zx`. So this works:
+    
+    ```typescript
+    const value = await cached("key1", () => fetch("https://example.com"))
+
+    import {$} from "zx"
+    const output = await cached("key2", () => $`sleep 1 && echo "slow process demo"`)
+    ```
+
+  - a `Promise<string>`
+
+  - a string. In this case the whole call is sync.
+  
+    ```typescript
+    const output = cached("key4", () =>
+      spawnSync("ls", { stdio: "pipe", encoding: "utf-8" }).stdout,
+    );
+    ```

package/index.d.ts

@@ -1,20 +1,4 @@
-/**
- * A cache designed to cache some text.
- */
-export declare function cached(
-/**
- * The key of the value.
- * Subsequent calls with the same key will return the cached value.
- */
-key: string, 
-/**
- * A fetcher function, called when the value isn't cached.
- *
- * This can return a string or a Promise<string>.
- *
- * This can also return a Promise<{ text: () => string | Promise<string> }>.
- * This means a Response or zx's ProcessOutput can be used directly.
- */
-fetcher: () => string | Promise<string> | Promise<{
+export declare function cached(key: string, fetcher: () => string): string;
+export declare function cached(key: string, fetcher: () => Promise<string> | Promise<{
     text: () => string | Promise<string>;
 }>): Promise<string>;

package/index.js

@@ -1,11 +1,11 @@
 // -*- lsp-disabled-clients: (ts-ls); -*-
-import { mkdirSync, writeFileSync, readFileSync, existsSync } from "node:fs";
+import { mkdirSync, writeFileSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { tmpdir } from "node:os";
 /**
  * A cache designed to cache some text.
  */
-export async function cached(
+export function cached(
 /**
  * The key of the value.
  * Subsequent calls with the same key will return the cached value.
@@ -21,18 +21,26 @@ key,
  */
 fetcher) {
     const cacheFile = join(tmpdir(), key);
-    const cacheHit = existsSync(cacheFile);
-    let text;
-    if (cacheHit) {
-        text = readFileSync(cacheFile, { encoding: "utf-8" });
-    }
-    else {
-        const result = await fetcher();
-        text = typeof result === "string" ? result : await result.text();
-    }
-    if (!cacheHit) {
+    function saveCache(text) {
         mkdirSync(dirname(cacheFile), { recursive: true });
         writeFileSync(cacheFile, text, { encoding: "utf-8" });
+        return text;
+    }
+    try {
+        return readFileSync(cacheFile, { encoding: "utf-8" });
+    }
+    catch (e) {
+        if (e.code !== "ENOENT") {
+            throw e;
+        }
+        const result = fetcher();
+        if (typeof result === "string") {
+            return saveCache(result);
+        }
+        else {
+            return result.then(async (v) => {
+                return saveCache(typeof v === "string" ? v : await v.text());
+            });
+        }
     }
-    return text;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kisaragi-hiu/cached-fetch",
-  "version": "0.2.0",
+  "version": "0.3.4",
   "description": "A cache in OS tmpdir useful for fetch()",
   "type": "module",
   "repository": {
@@ -15,10 +15,13 @@
   "author": "Kisaragi Hiu <mail@kisaragi-hiu.com>",
   "license": "MIT",
   "files": ["index.js", "index.d.ts"],
+  "main": "index.js",
+  "types": "index.d.ts",
   "devDependencies": {
     "@typescript/native-preview": "^7.0.0-dev.20250822.1"
   },
   "scripts": {
+    "test": "deno test -A",
     "build": "tsgo index.ts --noCheck -d -t esnext -m nodenext"
   }
 }