motion-canvas-cache 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Patrick Rathje
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,367 @@
+# Motion Canvas Cache
+
+A generic file caching library for Motion Canvas projects that provides both in-memory and server-side caching via Vite's HMR WebSocket.
+
+## Features
+
+- **Dual-layer caching**: In-memory cache for fast access + server-side cache for persistence
+- **Simple API**: Single `cached()` function that handles everything
+- **URL or Blob support**: Cache files from URLs or directly from Blob objects
+- **Auto MIME type detection**: Automatically detects content type from response headers
+- **Custom metadata**: Store arbitrary metadata alongside cached files
+- **HMR persistence**: Cache persists across hot module reloads
+- **Works standalone**: In-memory cache works even without the server plugin
+- **Generic file support**: Supports any file type (audio, video, images, documents, etc.)
+
+## Installation
+
+```bash
+npm install motion-canvas-cache
+```
+
+## Usage
+
+### 1. Enable the Vite Plugin
+
+Add the plugin to your `vite.config.ts`:
+
+```typescript
+import {defineConfig} from 'vite';
+import motionCanvas from '@motion-canvas/vite-plugin';
+import {motionCanvasCachePlugin} from 'motion-canvas-cache';
+
+export default defineConfig({
+  plugins: [
+    motionCanvas(),
+    motionCanvasCachePlugin({
+      cachePath: 'motion-canvas-cache', // Optional: default cache directory
+      maxFileSize: 50, // Optional: max file size in MB (default: 50)
+    }),
+  ]
+});
+```
+
+### 2. Use in Motion Canvas
+
+Since Motion Canvas uses generator functions and you can't use `yield*` inside JSX, the pattern is:
+
+1. **Preload assets** at the beginning of your scene using `yield cache()`
+2. **Use synchronously** in JSX with `cached()`
+
+```typescript
+import {makeScene2D, Img, Audio} from '@motion-canvas/2d';
+import {cache, cached} from 'motion-canvas-cache';
+
+export default makeScene2D(function* (view) {
+  // 1. Preload all assets at the beginning using yield
+  yield cache('https://example.com/image.png', {
+    metadata: {width: 800, height: 600},
+  });
+
+  yield cache('https://example.com/audio.mp3', {
+    metadata: {duration: 3.5},
+  });
+
+  // 2. Use synchronously in JSX - no yield needed!
+  view.add(
+    <Img src={cached('https://example.com/image.png')} />
+  );
+
+  view.add(
+    <Audio src={cached('https://example.com/audio.mp3')} />
+  );
+});
+```
+
+**Alternative: Preload in variables first**
+
+```typescript
+export default makeScene2D(function* (view) {
+  // Preload and store in variables
+  const imageUrl = yield cache('https://example.com/image.png');
+  const audioUrl = yield cache('https://example.com/audio.mp3');
+
+  // Use directly in JSX
+  view.add(<Img src={imageUrl} />);
+  view.add(<Audio src={audioUrl} />);
+});
+```
+
+### 3. Conditional Loading
+
+If you need to check if something is cached before loading:
+
+```typescript
+export default makeScene2D(function* (view) {
+  const url = 'https://example.com/image.png';
+
+  // Check if already cached (synchronous)
+  if (!cached(url)) {
+    // Not cached yet, load it
+    yield cache(url);
+  }
+
+  // Now use it in JSX
+  view.add(<Img src={cached(url)} />);
+});
+```
+
+### Advanced Usage
+
+#### Cache with custom MIME type override
+```typescript
+export default makeScene2D(function* (view) {
+  // Preload with custom MIME type
+  yield cache('https://example.com/file', {
+    mimeType: 'audio/mpeg', // Override auto-detected MIME type
+    metadata: {duration: 5.2, title: 'My Audio'},
+  });
+
+  // Use in JSX
+  view.add(<Audio src={cached('https://example.com/file')} />);
+});
+```
+
+#### Cache a Blob directly
+```typescript
+import {Cache, CacheUtils, cached} from 'motion-canvas-cache';
+
+export default makeScene2D(function* (view) {
+  const cache = Cache.getInstance();
+  const myBlob = new Blob(['content'], {type: 'text/plain'});
+
+  // Generate a cache key
+  const cacheKey = CacheUtils.generateCacheKey('my-content', ['text']);
+
+  // Cache the blob (use yield* in Motion Canvas)
+  yield* cache.cacheBlob(cacheKey, myBlob, {
+    source: 'user-generated',
+  });
+
+  // Use the cached result
+  const textUrl = cache.get(cacheKey).url;
+});
+```
+
+#### Custom cache key options
+```typescript
+export default makeScene2D(function* (view) {
+  const baseUrl = 'https://api.example.com/audio';
+
+  // Preload different variants
+  yield cache(baseUrl, {
+    cacheKeyOptions: ['fast', 'lowquality'],
+    metadata: {speed: 'fast'},
+  });
+
+  yield cache(baseUrl, {
+    cacheKeyOptions: ['slow', 'highquality'],
+    metadata: {speed: 'slow'},
+  });
+
+  // Use them
+  const fastUrl = cached(baseUrl, {cacheKeyOptions: ['fast', 'lowquality']});
+  const slowUrl = cached(baseUrl, {cacheKeyOptions: ['slow', 'highquality']});
+});
+```
+
+#### Override cache key completely
+```typescript
+export default makeScene2D(function* (view) {
+  // Cache with custom key
+  yield cache('https://api.tts.com/generate?text=hello', {
+    cacheKey: 'my-custom-cache-key',
+    metadata: {duration: 2.5},
+  });
+
+  // Retrieve with same custom key
+  const audioUrl = cached('https://api.tts.com/generate?text=hello', {
+    cacheKey: 'my-custom-cache-key',
+  });
+
+  // Note: If both cacheKey and cacheKeyOptions are provided,
+  // cacheKeyOptions will be ignored and a warning will be logged
+});
+```
+
+#### Use URL or Request objects
+```typescript
+export default makeScene2D(function* (view) {
+  // With URL object
+  const url = new URL('https://example.com/image.png');
+  yield cache(url);
+  view.add(<Img src={cached(url)} />);
+
+  // With Request object (for POST requests, custom headers, etc.)
+  const request = new Request('https://api.tts.com/generate', {
+    method: 'POST',
+    headers: {'Content-Type': 'application/json'},
+    body: JSON.stringify({text: 'Hello world'}),
+  });
+
+  yield cache(request, {
+    cacheKey: 'hello-world-audio',
+    metadata: {duration: 2.5},
+  });
+
+  const audioUrl = cached(request, {cacheKey: 'hello-world-audio'});
+});
+```
+
+#### Custom fetch options
+```typescript
+export default makeScene2D(function* (view) {
+  // Preload with fetch options
+  yield cache('https://api.tts.com/generate', {
+    fetchOptions: {
+      method: 'POST',
+      headers: {'Authorization': 'Bearer token123'},
+      body: JSON.stringify({text: 'Hello'}),
+    },
+    metadata: {duration: 3.5},
+  });
+
+  // Use the cached result
+  const audioUrl = cached('https://api.tts.com/generate');
+  view.add(<Audio src={audioUrl} />);
+});
+```
+
+## How It Works
+
+1. **First call**: When you call `cache()` with a URL:
+   - Checks in-memory cache first
+   - Checks server cache via HMR WebSocket
+   - If not cached, fetches from URL
+   - Stores in both memory and server cache
+   - Returns the cached URL (blob URL or server path)
+
+2. **Subsequent calls**: Same cache key returns instantly from memory or server cache
+
+3. **HMR updates**: Cache persists across hot module reloads for fast development
+
+## API Reference
+
+### `cache(input, options?)`
+
+Async function to fetch and cache URLs. **Use with `yield` in Motion Canvas.**
+
+**Parameters:**
+- `input`: `string | URL | Request` - URL to fetch and cache
+  - `string` - URL as string
+  - `URL` - URL object
+  - `Request` - Request object (for POST, custom headers, etc.)
+- `options`: `CachedOptions` (optional)
+  - `metadata?: Record<string, any>` - Custom metadata to store
+  - `mimeType?: string` - Override MIME type (auto-detected if not provided)
+  - `cacheKeyOptions?: string[]` - Additional options for cache key generation
+  - `cacheKey?: string` - Override the automatically generated cache key (if provided, `cacheKeyOptions` will be ignored)
+  - `fetchOptions?: RequestInit` - Additional options to pass to fetch() (method, headers, body, etc.)
+
+**Returns:** `Promise<string>` - The cached URL (blob URL or server path) ready to use in Motion Canvas components
+
+**Usage:** `const url = yield cache('https://...');`
+
+### `cached(input, options?)`
+
+Synchronously get a cached URL. **No `yield` needed - use directly in JSX!**
+
+**Parameters:**
+- Same as `cache()`
+
+**Returns:** `string | null` - The cached URL if found, otherwise null
+
+**Usage:** `const url = cached('https://...'); // No yield needed!`
+
+### `Cache` class
+
+Singleton cache manager.
+
+**Methods:**
+- `Cache.getInstance()` - Get the singleton instance
+- `get(cacheKey)` - Get cached result
+- `cacheResult(cacheKey, url, metadata?)` - Store URL in memory cache
+- `cacheBlob(cacheKey, blob, metadata?, mimeType?)` - Cache a Blob with optional metadata and MIME type
+- `checkServerCache(cacheKey)` - Check server cache
+- `uploadToServer(cacheKey, data, mimeType, metadata?)` - Upload to server
+
+### `CacheUtils` class
+
+Utility functions for cache operations.
+
+**Methods:**
+- `CacheUtils.generateCacheKey(content, opts?)` - Generate 8-character hex cache key
+- `CacheUtils.blobToDataUrl(blob)` - Convert Blob to base64 data URL
+- `CacheUtils.streamToArrayBuffer(stream)` - Convert ReadableStream to ArrayBuffer
+
+## Integration with Motion Canvas Narrator
+
+This library was extracted from the motion-canvas-narrator project and can be reused there. Example integration:
+
+```typescript
+// In your narrator provider (generator function)
+import {cache, cached} from 'motion-canvas-cache';
+
+function* generateAudio(text: string, voiceId: string, modelId: string) {
+  const url = 'https://api.example.com/tts';
+
+  // Check if already cached
+  const cachedUrl = cached(url, {
+    cacheKeyOptions: [text, voiceId, modelId],
+  });
+
+  if (cachedUrl) {
+    return cachedUrl;
+  }
+
+  // Cache with audio duration metadata and return the cached URL
+  return yield cache(url, {
+    fetchOptions: {
+      method: 'POST',
+      body: JSON.stringify({text, voice: voiceId}),
+    },
+    metadata: {duration: 3.5},
+    cacheKeyOptions: [text, voiceId, modelId], // Unique per text/voice/model
+  });
+}
+```
+
+## Cache Directory Structure
+
+Server-side cached files are stored as:
+
+```
+motion-canvas-cache/
+├── 20fac170.mp3           # Cached file (8-char hash + extension)
+├── 20fac170.meta.json     # Metadata file
+├── a1b2c3d4.png
+├── a1b2c3d4.meta.json
+└── ...
+```
+
+Metadata file example:
+```json
+{
+  "cacheKey": "20fac170",
+  "mimeType": "audio/mpeg",
+  "fileSize": 55296,
+  "fileName": "20fac170.mp3",
+  "createdAt": "2024-01-01T12:00:00.000Z",
+  "duration": 3.5
+}
+```
+
+## Cleanup
+
+To clear the server cache, visit:
+```
+http://localhost:9000/__cache-cleanup
+```
+
+## Contributing
+
+Contributions are welcome! Please open issues or pull requests.
+
+## License
+
+MIT

package/dist/Cache.d.ts

@@ -0,0 +1,156 @@
+declare global {
+    interface ImportMeta {
+        hot?: {
+            on: (event: string, callback: (data: any) => void) => void;
+            send: (event: string, data: any) => void;
+        };
+    }
+}
+export interface CachedResult {
+    url: string;
+    metadata?: Record<string, any>;
+}
+type CacheKey = string;
+/**
+ * Options for caching operations
+ */
+export interface CacheOptions {
+    cacheKey?: string;
+    metadata?: Record<string, any>;
+    mimeType?: string;
+    fetchOptions?: RequestInit;
+}
+/**
+ * Cache options with required cacheKey (used by cacheBlob and cacheArrayBuffer)
+ */
+export interface CacheOptionsWithKey extends Omit<CacheOptions, 'cacheKey' | 'fetchOptions'> {
+    cacheKey: string;
+}
+export declare class Cache {
+    private static instance;
+    private cache;
+    private pendingRequests;
+    private serverAvailablePromise;
+    private constructor();
+    static getInstance(): Cache;
+    private initializeHMR;
+    get(cacheKey: CacheKey): CachedResult | null;
+    /**
+     * Check if a cache key exists in memory cache (synchronous)
+     *
+     * @param cacheKey - The cache key to check
+     * @returns true if the key exists in memory cache
+     */
+    has(cacheKey: CacheKey): boolean;
+    private set;
+    cacheResult(cacheKey: CacheKey, url: string, metadata?: Record<string, any>): void;
+    /**
+     * Cache a Blob (base caching method)
+     *
+     * @param blob - The Blob to cache
+     * @param options - Cache options (cacheKey is required, metadata, mimeType)
+     * @returns The blob URL that can be used to reference the cached blob
+     */
+    cacheBlob(blob: Blob, options: CacheOptionsWithKey): Promise<string>;
+    /**
+     * Cache an ArrayBuffer (calls cacheBlob)
+     *
+     * @param arrayBuffer - The ArrayBuffer to cache
+     * @param options - Cache options (cacheKey is required, metadata, mimeType)
+     * @returns The blob URL that can be used to reference the cached data
+     */
+    cacheArrayBuffer(arrayBuffer: ArrayBuffer, options: CacheOptionsWithKey): Promise<string>;
+    /**
+     * Cache a URL by fetching and caching the response (calls cacheArrayBuffer)
+     *
+     * @param input - The URL to fetch and cache (string, URL object, or Request object)
+     * @param options - Cache options (cacheKey, metadata, mimeType, fetchOptions)
+     * @returns The blob URL that can be used to reference the cached data
+     */
+    cacheUrl(input: string | URL, options?: CacheOptions): Promise<string>;
+    checkServerCache(cacheKey: CacheKey): Promise<CachedResult | null>;
+    uploadToServer(cacheKey: CacheKey, data: ArrayBuffer, mimeType: string, metadata?: Record<string, any>): Promise<void>;
+    streamToArrayBuffer(stream: ReadableStream): Promise<ArrayBuffer>;
+}
+export interface CachedOptions {
+    metadata?: Record<string, any>;
+    mimeType?: string;
+    cacheKeyOptions?: string[];
+    cacheKey?: string;
+    fetchOptions?: RequestInit;
+}
+/**
+ * Async function to fetch and cache a file from a URL
+ *
+ * @param input - URL to fetch (string, URL object, or Request object)
+ * @param options - Optional configuration
+ *   - metadata: Custom metadata to store with the cached file
+ *   - mimeType: Override MIME type (auto-detected if not provided)
+ *   - cacheKeyOptions: Additional options for cache key generation
+ *   - cacheKey: Override the automatically generated cache key
+ *   - fetchOptions: Additional options to pass to fetch()
+ * @returns Promise that resolves to the cached URL (blob URL or server path)
+ *
+ * @example
+ * // In Motion Canvas, use yield to await the promise
+ * export default makeScene2D(function* (view) {
+ *   // Preload the image
+ *   yield cache('https://example.com/image.png', {
+ *     metadata: { width: 800, height: 600 },
+ *     mimeType: 'image/png'
+ *   });
+ *
+ *   // Use synchronously in JSX
+ *   view.add(<Img src={cached('https://example.com/image.png')} />);
+ * });
+ *
+ * @example
+ * // Cache with URL object
+ * const url = new URL('https://example.com/image.png');
+ * yield cache(url);
+ *
+ *
+ * @example
+ * // Cache with fetch options
+ * yield cache('https://api.tts.com/generate', {
+ *   fetchOptions: {
+ *     method: 'POST',
+ *     headers: { 'Content-Type': 'application/json' },
+ *     body: JSON.stringify({text: 'Hello'}),
+ *   },
+ *   metadata: { duration: 3.5 }
+ * });
+ */
+export declare function cache(input: string | URL, options?: CachedOptions): Promise<string>;
+/**
+ * Synchronously get a cached URL (no async/yield needed)
+ *
+ * @param input - URL to check (string, URL object, or Request object)
+ * @param options - Optional configuration (same as cache function)
+ * @returns The cached URL if found, otherwise null
+ *
+ * @example
+ * // Use directly in JSX without yield
+ * export default makeScene2D(function* (view) {
+ *   // Preload first
+ *   yield cache('https://example.com/image.png');
+ *
+ *   // Use synchronously in JSX - no yield needed!
+ *   view.add(<Img src={cached('https://example.com/image.png')} />);
+ * });
+ *
+ * @example
+ * // Conditional loading
+ * export default makeScene2D(function* (view) {
+ *   const url = 'https://example.com/image.png';
+ *
+ *   if (!cached(url)) {
+ *     yield cache(url);
+ *   }
+ *
+ *   view.add(<Img src={cached(url)} />);
+ * });
+ */
+export declare function cached(input: string | URL, options?: CachedOptions): string | null;
+export {};
+//# sourceMappingURL=Cache.d.ts.map

package/dist/Cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../src/Cache.ts"],"names":[],"mappings":"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"}

package/dist/CacheUtils.d.ts

@@ -0,0 +1,20 @@
+export declare class CacheUtils {
+    /**
+     * Generates a cache key from content and options
+     */
+    static generateCacheKey(content: string, opts?: string[]): string;
+    /**
+     * Simple hash function for generating cache keys
+     * Always returns exactly 8 hexadecimal characters
+     */
+    private static simpleHash;
+    /**
+     * Converts a Blob to a data URL (base64 encoded)
+     */
+    static blobToDataUrl(blob: Blob): Promise<string>;
+    /**
+     * Converts a ReadableStream to ArrayBuffer
+     */
+    static streamToArrayBuffer(stream: ReadableStream): Promise<ArrayBuffer>;
+}
+//# sourceMappingURL=CacheUtils.d.ts.map

package/dist/CacheUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CacheUtils.d.ts","sourceRoot":"","sources":["../src/CacheUtils.ts"],"names":[],"mappings":"AAAA,qBAAa,UAAU;IACrB;;OAEG;WACW,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,GAAE,MAAM,EAAO,GAAG,MAAM;IAK5E;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,UAAU;IAWzB;;OAEG;WACW,aAAa,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC;IASxD;;OAEG;WACiB,mBAAmB,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC;CA2BtF"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { Cache, CachedResult, CacheOptions, CacheOptionsWithKey, cache, cached, CachedOptions } from './Cache';
+export { CacheUtils } from './CacheUtils';
+export { motionCanvasCachePlugin, MotionCanvasCachePluginOptions, } from './vite-plugin/plugin';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,EAAC,MAAM,SAAS,CAAC;AAC7G,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AAGxC,OAAO,EACL,uBAAuB,EACvB,8BAA8B,GAC/B,MAAM,sBAAsB,CAAC"}