@bendyline/squisq 1.4.0 → 1.4.1

package/dist/storage/index.d.ts

@@ -1,10 +1,159 @@
-export type { StorageAdapter } from './Storage.js';
-export { MemoryStorageAdapter } from './MemoryStorageAdapter.js';
-export { LocalStorageAdapter } from './LocalStorageAdapter.js';
-export { LocalForageAdapter } from './LocalForageAdapter.js';
-export type { LocalForageAdapterOptions } from './LocalForageAdapter.js';
-export type { ContentContainer, ContentEntry } from './ContentContainer.js';
-export { MemoryContentContainer, findDocumentPath } from './ContentContainer.js';
-export { ScopedContentContainer, scopeContainer } from './ScopedContentContainer.js';
-export { createMediaProviderFromContainer } from './MediaProviderFromContainer.js';
-//# sourceMappingURL=index.d.ts.map
+import { C as ContentContainer, a as ContentEntry } from '../ContentContainer-DNx460y8.js';
+export { M as MemoryContentContainer, f as findDocumentPath } from '../ContentContainer-DNx460y8.js';
+import { a as MediaProvider } from '../MediaProvider-wpSe21B3.js';
+
+/**
+ * Storage - Abstract persistence interface
+ *
+ * Defines the contract for persistent storage across different environments.
+ * All values are JSON-serialized, so any serializable value can be stored.
+ * Keys can be automatically namespaced with a configurable prefix.
+ */
+/** Storage adapter interface - implemented by environment-specific adapters */
+interface StorageAdapter {
+    /** Get a value by key, returns null if not found */
+    get<T>(key: string): Promise<T | null>;
+    /** Set a value for a key */
+    set<T>(key: string, value: T): Promise<void>;
+    /** Remove a value by key */
+    remove(key: string): Promise<void>;
+    /** Clear all stored values (within our namespace) */
+    clear(): Promise<void>;
+    /** Get all keys (within our namespace) */
+    keys(): Promise<string[]>;
+    /** Check if this adapter supports enumeration */
+    readonly supportsEnumeration: boolean;
+}
+
+/**
+ * In-memory storage adapter for testing and SSR environments.
+ * Data does not persist across page reloads.
+ */
+
+declare class MemoryStorageAdapter implements StorageAdapter {
+    readonly supportsEnumeration = true;
+    private store;
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T): Promise<void>;
+    remove(key: string): Promise<void>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+}
+
+/**
+ * localStorage adapter for web browsers.
+ * Supports a configurable key prefix to namespace stored data.
+ */
+
+declare class LocalStorageAdapter implements StorageAdapter {
+    readonly supportsEnumeration = true;
+    private prefix;
+    constructor(prefix?: string);
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T): Promise<void>;
+    remove(key: string): Promise<void>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+}
+
+/**
+ * LocalForage adapter - IndexedDB storage with automatic fallbacks.
+ *
+ * Uses localforage which provides IndexedDB storage with automatic
+ * fallbacks to WebSQL and localStorage. This allows storing much more
+ * data than raw localStorage (which is limited to ~5MB).
+ *
+ * Unlike LocalStorageAdapter, this adapter can store binary data
+ * (ArrayBuffer, Blob, Uint8Array) natively without JSON serialization.
+ *
+ * Ported from qualla-internal/shared/services/StorageAdapters.ts with
+ * configurable store name and key prefix.
+ */
+
+interface LocalForageAdapterOptions {
+    /** IndexedDB database name (default: 'squisq') */
+    name?: string;
+    /** IndexedDB object store name (default: 'data') */
+    storeName?: string;
+    /** Key prefix for namespacing (default: '') */
+    prefix?: string;
+    /** Human-readable description (default: 'Squisq storage') */
+    description?: string;
+}
+declare class LocalForageAdapter implements StorageAdapter {
+    readonly supportsEnumeration = true;
+    private store;
+    private prefix;
+    constructor(options?: LocalForageAdapterOptions);
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T): Promise<void>;
+    remove(key: string): Promise<void>;
+    clear(): Promise<void>;
+    keys(): Promise<string[]>;
+}
+
+/**
+ * ScopedContentContainer
+ *
+ * Wraps a parent {@link ContentContainer} and prefixes every path with a
+ * fixed subfolder, presenting that subfolder as the root. Useful for
+ * sidecar folders (e.g. `<imagebasename>_files/`) where a component
+ * should be able to read/write/list files relative to its own root
+ * without knowing where it lives in the parent tree.
+ *
+ * Scopes nest: `scopeContainer(scopeContainer(parent, 'a'), 'b')` is
+ * equivalent to `scopeContainer(parent, 'a/b')`.
+ *
+ * `getDocumentPath()` always returns `null` for scoped sidecars — they
+ * are not document roots.
+ */
+
+/**
+ * A ContentContainer view rooted at a subfolder of a parent container.
+ * All paths passed to / returned from this container are relative to
+ * the subfolder; the parent never sees an unprefixed path.
+ */
+declare class ScopedContentContainer implements ContentContainer {
+    private readonly parent;
+    /** Prefix without trailing slash. */
+    readonly prefix: string;
+    /** Prefix with trailing slash. */
+    private readonly prefixSlash;
+    constructor(parent: ContentContainer, prefix: string);
+    private toParent;
+    /** Strip the prefix from a parent-space path. Returns null if the path is outside the scope. */
+    private fromParent;
+    readFile(path: string): Promise<ArrayBuffer | null>;
+    writeFile(path: string, data: ArrayBuffer | Uint8Array, mimeType?: string): Promise<void>;
+    removeFile(path: string): Promise<void>;
+    listFiles(prefix?: string): Promise<ContentEntry[]>;
+    exists(path: string): Promise<boolean>;
+    /** Sidecars are not document roots. */
+    getDocumentPath(): Promise<string | null>;
+    readDocument(): Promise<string | null>;
+    writeDocument(): Promise<void>;
+}
+/** Factory: convenience wrapper for `new ScopedContentContainer(parent, prefix)`. */
+declare function scopeContainer(parent: ContentContainer, prefix: string): ScopedContentContainer;
+
+/**
+ * MediaProviderFromContainer — bridges ContentContainer to MediaProvider.
+ *
+ * Creates a MediaProvider that resolves relative paths by reading binary data
+ * from a ContentContainer and generating blob URLs. Blob URLs are cached and
+ * revoked on dispose().
+ *
+ * This allows any ContentContainer (memory, slot-backed, zip-loaded) to be
+ * used with existing rendering components (DocPlayer, ImageLayer, VideoLayer)
+ * that consume MediaProvider.
+ */
+
+/**
+ * Create a MediaProvider backed by a ContentContainer.
+ *
+ * @param container — The ContentContainer to read/write media from
+ * @returns A MediaProvider that resolves paths to blob URLs
+ */
+declare function createMediaProviderFromContainer(container: ContentContainer): MediaProvider;
+
+export { ContentContainer, ContentEntry, LocalForageAdapter, type LocalForageAdapterOptions, LocalStorageAdapter, MemoryStorageAdapter, ScopedContentContainer, type StorageAdapter, createMediaProviderFromContainer, scopeContainer };

package/dist/storage/index.js

@@ -1,7 +1,21 @@
-export { MemoryStorageAdapter } from './MemoryStorageAdapter.js';
-export { LocalStorageAdapter } from './LocalStorageAdapter.js';
-export { LocalForageAdapter } from './LocalForageAdapter.js';
-export { MemoryContentContainer, findDocumentPath } from './ContentContainer.js';
-export { ScopedContentContainer, scopeContainer } from './ScopedContentContainer.js';
-export { createMediaProviderFromContainer } from './MediaProviderFromContainer.js';
+import {
+  LocalForageAdapter,
+  LocalStorageAdapter,
+  MemoryContentContainer,
+  MemoryStorageAdapter,
+  ScopedContentContainer,
+  createMediaProviderFromContainer,
+  findDocumentPath,
+  scopeContainer
+} from "../chunk-2TMAWB4Y.js";
+export {
+  LocalForageAdapter,
+  LocalStorageAdapter,
+  MemoryContentContainer,
+  MemoryStorageAdapter,
+  ScopedContentContainer,
+  createMediaProviderFromContainer,
+  findDocumentPath,
+  scopeContainer
+};
 //# sourceMappingURL=index.js.map

package/dist/storage/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAG7D,OAAO,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACjF,OAAO,EAAE,sBAAsB,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AACrF,OAAO,EAAE,gCAAgC,EAAE,MAAM,iCAAiC,CAAC"}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/timing/index.d.ts

@@ -1,4 +1,109 @@
-export { DEFAULT_WORDS_PER_SECOND, estimateSpokenWordCount, countSpokenWords, estimateTimeFromText, calculatePrefixDuration, estimateNarrationDuration, } from './narrationTiming.js';
-export { estimateReadingTime, estimateNarrationTime } from './readingTime.js';
-export type { ReadingTimeEstimate, ReadingTimeOptions, NarrationTimeEstimate, NarrationTimeOptions, } from './readingTime.js';
-//# sourceMappingURL=index.d.ts.map
+/**
+ * Narration timing estimation.
+ *
+ * Estimates how long text takes to speak aloud, accounting for:
+ * - Numbers spoken as multiple words (e.g., "1910" → "nineteen ten")
+ * - Pauses at commas
+ * - Year pronunciation conventions (1000–2099)
+ *
+ * Ported from qualla-internal's AudioTiming.ts (pure functions, no Node.js deps).
+ */
+/** Default speaking rate in words per second (~150 WPM). */
+declare const DEFAULT_WORDS_PER_SECOND = 2.5;
+/**
+ * Estimate how many "spoken word equivalents" a single token represents.
+ * Numbers get expanded (e.g., "175,000" → ~5 words × 1.3 multiplier).
+ */
+declare function estimateSpokenWordCount(token: string): number;
+/**
+ * Count "spoken word equivalents" in a block of text,
+ * expanding numbers and adding comma pauses.
+ */
+declare function countSpokenWords(text: string): number;
+/**
+ * Estimate audio time at a character offset using word-proportion mapping.
+ *
+ * Given the full source text and a character position, returns the
+ * estimated time (in seconds) at which that position would be spoken.
+ *
+ * @param text - Full source text
+ * @param charOffset - Character offset to estimate timing for
+ * @param totalDuration - Total audio duration in seconds
+ * @returns Estimated time in seconds
+ */
+declare function estimateTimeFromText(text: string, charOffset: number, totalDuration: number): number;
+/**
+ * Estimate how long a spoken prefix adds to audio duration.
+ *
+ * When audio includes a spoken title or header before the main content,
+ * this calculates the extra duration to offset timing calculations.
+ *
+ * @param prefix - Prefix text (e.g., an article title spoken before the body)
+ * @param wordsPerSecond - Speaking rate (default: 2.5)
+ * @returns Estimated duration in seconds
+ */
+declare function calculatePrefixDuration(prefix: string, wordsPerSecond?: number): number;
+/**
+ * Estimate narration duration for a block of text.
+ *
+ * @param text - The text to estimate
+ * @param wordsPerSecond - Speaking rate (default: 2.5, i.e. ~150 WPM)
+ * @returns Duration in seconds
+ */
+declare function estimateNarrationDuration(text: string, wordsPerSecond?: number): number;
+
+/**
+ * Reading time estimation.
+ *
+ * Estimates how long it takes to read text silently vs. narrate it aloud.
+ * Uses configurable words-per-minute rates.
+ */
+/** Result of a reading-time estimate. */
+interface ReadingTimeEstimate {
+    /** Number of words (plain word count, not spoken equivalents). */
+    words: number;
+    /** Estimated minutes (decimal). */
+    minutes: number;
+    /** Estimated seconds (rounded). */
+    seconds: number;
+}
+/** Options for reading-time estimation. */
+interface ReadingTimeOptions {
+    /** Words per minute for silent reading (default: 200). */
+    wordsPerMinute?: number;
+}
+/**
+ * Estimate silent reading time for a block of text.
+ *
+ * @param text - The text to estimate
+ * @param options - Optional configuration
+ * @returns Word count + time estimate
+ */
+declare function estimateReadingTime(text: string, options?: ReadingTimeOptions): ReadingTimeEstimate;
+/** Result of a narration-time estimate. */
+interface NarrationTimeEstimate {
+    /** Spoken word equivalents (numbers expanded, comma pauses added). */
+    spokenWords: number;
+    /** Estimated minutes (decimal). */
+    minutes: number;
+    /** Estimated seconds (rounded). */
+    seconds: number;
+}
+/** Options for narration-time estimation. */
+interface NarrationTimeOptions {
+    /** Words per second for narration (default: 2.5 ≈ 150 WPM). */
+    wordsPerSecond?: number;
+}
+/**
+ * Estimate narration (spoken) time for a block of text.
+ *
+ * Unlike silent reading, this accounts for numbers being spoken as
+ * multiple words and pauses at commas.
+ *
+ * @param text - The text to estimate
+ * @param options - Optional configuration
+ * @returns Spoken word equivalents + time estimate
+ */
+declare function estimateNarrationTime(text: string, options?: NarrationTimeOptions): NarrationTimeEstimate;
+
+export { DEFAULT_WORDS_PER_SECOND, type NarrationTimeEstimate, type NarrationTimeOptions, type ReadingTimeEstimate, type ReadingTimeOptions, calculatePrefixDuration, countSpokenWords, estimateNarrationDuration, estimateNarrationTime, estimateReadingTime, estimateSpokenWordCount, estimateTimeFromText };

package/dist/timing/index.js

@@ -1,3 +1,24 @@
-export { DEFAULT_WORDS_PER_SECOND, estimateSpokenWordCount, countSpokenWords, estimateTimeFromText, calculatePrefixDuration, estimateNarrationDuration, } from './narrationTiming.js';
-export { estimateReadingTime, estimateNarrationTime } from './readingTime.js';
+import "../chunk-DNJKBAI7.js";
+import {
+  estimateNarrationTime,
+  estimateReadingTime
+} from "../chunk-4X3JQXNM.js";
+import {
+  DEFAULT_WORDS_PER_SECOND,
+  calculatePrefixDuration,
+  countSpokenWords,
+  estimateNarrationDuration,
+  estimateSpokenWordCount,
+  estimateTimeFromText
+} from "../chunk-3E5F2XMR.js";
+export {
+  DEFAULT_WORDS_PER_SECOND,
+  calculatePrefixDuration,
+  countSpokenWords,
+  estimateNarrationDuration,
+  estimateNarrationTime,
+  estimateReadingTime,
+  estimateSpokenWordCount,
+  estimateTimeFromText
+};
 //# sourceMappingURL=index.js.map

package/dist/timing/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/timing/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,uBAAuB,EACvB,gBAAgB,EAChB,oBAAoB,EACpB,uBAAuB,EACvB,yBAAyB,GAC1B,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAE,mBAAmB,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC"}
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/transform/index.d.ts

@@ -1,6 +1,175 @@
-export { applyTransform } from './applyTransform.js';
-export { resolveTransformStyle, getTransformStyleIds, getTransformStyleSummaries, DEFAULT_TRANSFORM_STYLE_ID, } from './registry.js';
-export type { TransformStyleId, TransformStyleSummary, TransformStyleConfig, TransformImage, TransformOptions, TransformResult, } from './types.js';
-export type { AnalyzedBlock, BlockImage } from './blockAnalyzer.js';
-export { analyzeBlocks, extractDocImages } from './blockAnalyzer.js';
-//# sourceMappingURL=index.d.ts.map
+import { j as ColorScheme, s as Doc, B as Block } from '../Doc-BeSeH2iX.js';
+import { d as ExtractionType, E as ExtractedElement, b as ExtractionOptions } from '../contentExtractor-BNfVJV2U.js';
+import '../types-BdZkdJ3z.js';
+
+/**
+ * Transform Types
+ *
+ * Defines the type system for doc block transforms — algorithms that take
+ * an existing Doc and produce a new Doc with blocks optimized for visual
+ * presentation. Transforms are read-only on the input and deterministic.
+ */
+
+/** Identifier for a registered transform style. */
+type TransformStyleId = string;
+/** Summary info for UI dropdowns (mirrors getThemeSummaries pattern). */
+interface TransformStyleSummary {
+    id: TransformStyleId;
+    name: string;
+    description: string;
+}
+/** Declarative configuration controlling how a style transforms content. */
+interface TransformStyleConfig {
+    /** Unique style identifier. */
+    id: TransformStyleId;
+    /** Human-readable name for UI display. */
+    name: string;
+    /** Short description for UI tooltips. */
+    description: string;
+    /**
+     * Minimum confidence for extracted elements to become template blocks (0–1).
+     * Higher values = fewer but higher-quality transformations.
+     */
+    minConfidence: number;
+    /**
+     * Maximum fraction of blocks that get transformed (0–1).
+     * 0.2 = light touch, 0.8 = aggressive restructuring.
+     */
+    transformRatio: number;
+    /** Which extraction types this style prefers, in priority order. */
+    preferredTypes: ExtractionType[];
+    /** Color schemes to rotate through on template blocks. */
+    colorSchemes: ColorScheme[];
+    /** Whether to insert sectionHeader blocks between groups. */
+    insertSectionHeaders: boolean;
+    /** Whether to interleave imageWithCaption blocks when images are available. */
+    interleaveImages: boolean;
+    /** Target density of template blocks per section. */
+    blocksPerSection: {
+        min: number;
+        max: number;
+    };
+    /** Transition style preference for transformed blocks. */
+    transitionStyle: 'cut' | 'fade' | 'dissolve' | 'mixed';
+}
+/** Image metadata for image interleaving. */
+interface TransformImage {
+    /** Image source path or URL. */
+    src: string;
+    /** Alt text for accessibility. */
+    alt?: string;
+    /** Photo credit. */
+    credit?: string;
+    /** License identifier. */
+    license?: string;
+}
+/** Options passed to `applyTransform()`. */
+interface TransformOptions {
+    /** Deterministic seed. Default: hash of doc.articleId. */
+    seed?: number;
+    /** Available images for image interleaving / accent images. */
+    images?: TransformImage[];
+    /** Theme ID to embed in the output Doc. */
+    themeId?: string;
+    /** Override specific style config values. */
+    overrides?: Partial<TransformStyleConfig>;
+}
+/** Result of applying a transform. */
+interface TransformResult {
+    /** The transformed Doc. Input doc is NOT mutated. */
+    doc: Doc;
+    /** Statistics about what changed. */
+    stats: {
+        totalInputBlocks: number;
+        transformedBlocks: number;
+        insertedBlocks: number;
+    };
+}
+
+/**
+ * Apply Transform
+ *
+ * Main entry point for the transform module. Takes a Doc and a style,
+ * analyzes block content, selects extractions to promote, and returns
+ * a new Doc with blocks optimized for visual presentation.
+ *
+ * The input Doc is never mutated — a fresh Doc is always returned.
+ */
+
+/**
+ * Apply a transform style to a Doc, producing a new Doc with blocks
+ * optimized for visual presentation.
+ *
+ * @param doc - The source Doc (not mutated).
+ * @param styleId - Registered transform style id (e.g. 'documentary', 'magazine').
+ * @param options - Optional seed, images, theme override.
+ * @returns TransformResult with the new Doc and stats.
+ */
+declare function applyTransform(doc: Doc, styleId: TransformStyleId, options?: TransformOptions): TransformResult;
+
+/**
+ * Transform Style Registry
+ *
+ * Central registry of built-in transform styles. Follows the same pattern
+ * as themeLibrary.ts — a record of configs with lookup/summary helpers.
+ */
+
+/** Default style used when no id is provided. */
+declare const DEFAULT_TRANSFORM_STYLE_ID = "documentary";
+/**
+ * Resolve a transform style by id.
+ * Returns the default style if the id is not found.
+ */
+declare function resolveTransformStyle(id: string): TransformStyleConfig;
+/** Get all registered style ids. */
+declare function getTransformStyleIds(): string[];
+/** Get summary info for all styles (for UI dropdowns). */
+declare function getTransformStyleSummaries(): TransformStyleSummary[];
+
+/**
+ * Block Analyzer
+ *
+ * Walks Doc blocks, extracts plain text from their markdown contents,
+ * and runs the content extractor on each block to identify stats, dates,
+ * quotes, etc. that can be promoted to visual template blocks.
+ */
+
+/** An image found in a block's markdown contents. */
+interface BlockImage {
+    /** Image URL (relative or absolute). */
+    src: string;
+    /** Alt text. */
+    alt: string;
+    /** Index of the source block in the analyzed array. */
+    sourceBlockIndex: number;
+}
+/** A block enriched with extraction analysis. */
+interface AnalyzedBlock {
+    /** The original block. */
+    block: Block;
+    /** Plain text extracted from the block's contents. */
+    plainText: string;
+    /** Content extractions found in the block's text. */
+    extractions: ExtractedElement[];
+    /** Whether this block has child blocks. */
+    hasChildren: boolean;
+    /** Word count of the block's body text. */
+    bodyWordCount: number;
+    /** Images found in this block's markdown contents. */
+    images: BlockImage[];
+}
+/**
+ * Collect all unique images from all blocks in a Doc.
+ * Returns them as TransformImages for use in the transform pipeline.
+ */
+declare function extractDocImages(blocks: Block[]): TransformImage[];
+/**
+ * Analyze all blocks in a Doc, extracting text and running content extraction.
+ *
+ * @param blocks - The Doc's block array (may be nested via children).
+ * @param options - Extraction options (minConfidence, types filter).
+ * @returns Analyzed blocks with extractions, in flattened order.
+ */
+declare function analyzeBlocks(blocks: Block[], options?: ExtractionOptions): AnalyzedBlock[];
+
+export { type AnalyzedBlock, type BlockImage, DEFAULT_TRANSFORM_STYLE_ID, type TransformImage, type TransformOptions, type TransformResult, type TransformStyleConfig, type TransformStyleId, type TransformStyleSummary, analyzeBlocks, applyTransform, extractDocImages, getTransformStyleIds, getTransformStyleSummaries, resolveTransformStyle };