@wafflebase/cli 0.4.9 → 0.5.1

package/dist/config/session.js

@@ -1,74 +0,0 @@
-import { readFileSync, writeFileSync, unlinkSync, existsSync, mkdirSync, chmodSync, } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { homedir } from 'node:os';
-/**
- * Returns the default session file path: ~/.wafflebase/session.json
- */
-export function getSessionPath() {
-    if (process.env.WAFFLEBASE_SESSION) {
-        return process.env.WAFFLEBASE_SESSION;
-    }
-    return join(homedir(), '.wafflebase', 'session.json');
-}
-/**
- * Loads the session from disk. Returns null if the file does not exist or
- * contains invalid JSON.
- */
-export function loadSession(path = getSessionPath()) {
-    if (!existsSync(path))
-        return null;
-    try {
-        const raw = readFileSync(path, 'utf-8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Writes the session to disk with owner-only (0600) permissions.
- * Creates the parent directory if it does not exist.
- */
-export function saveSession(session, path = getSessionPath()) {
-    const dir = dirname(path);
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(path, JSON.stringify(session, null, 2), { mode: 0o600 });
-    // Explicitly chmod in case the file already existed with different permissions
-    chmodSync(path, 0o600);
-}
-/**
- * Deletes the session file if it exists. No-op otherwise.
- */
-export function clearSession(path = getSessionPath()) {
-    if (existsSync(path)) {
-        unlinkSync(path);
-    }
-}
-/**
- * Returns true when the session's expiresAt timestamp is in the past.
- */
-export function isSessionExpired(session) {
-    return new Date(session.expiresAt) <= new Date();
-}
-/**
- * Decodes the `exp` claim from a JWT's payload segment and returns an ISO
- * 8601 string.
- *
- * JWT format: <header>.<payload>.<signature>
- * The payload is base64url-encoded JSON.
- */
-export function decodeJwtExpiry(token) {
-    const parts = token.split('.');
-    if (parts.length < 2) {
-        throw new Error('Invalid JWT: expected at least 2 segments');
-    }
-    // Add padding back if needed for base64 decoding
-    const base64 = parts[1].replace(/-/g, '+').replace(/_/g, '/');
-    const padded = base64 + '='.repeat((4 - (base64.length % 4)) % 4);
-    const decoded = Buffer.from(padded, 'base64').toString('utf-8');
-    const payload = JSON.parse(decoded);
-    if (typeof payload.exp !== 'number') {
-        throw new Error('JWT payload does not contain an exp claim');
-    }
-    return new Date(payload.exp * 1000).toISOString();
-}

package/dist/docs/content.d.ts

@@ -1,37 +0,0 @@
-import { type Document } from '@wafflebase/docs';
-export declare const VALID_CONTENT_FORMATS: readonly ["json", "md", "text"];
-export type ContentFormat = (typeof VALID_CONTENT_FORMATS)[number];
-export declare const LOSSY_NOTICE = "Lossy conversion: see docs-cli design for the exact mapping";
-export declare const PAGES_FONT_WARNING: string;
-export declare function parseContentFormat(value: string): ContentFormat;
-/**
- * Surface for `runDocsContent` to talk back to the CLI without taking a
- * direct dependency on `process.stdout` / `process.stderr` / `fs`. The
- * command wires the real implementations; tests inject in-memory
- * collectors.
- */
-export interface ContentIO {
-    stdout: (text: string) => void;
-    stderr: (line: string) => void;
-    /** Write `text` to `path`. Throws if the file exists and `force` is false. */
-    writeFile: (path: string, text: string, force: boolean) => void;
-}
-export declare const defaultIO: ContentIO;
-export interface RunContentArgs {
-    doc: Document;
-    format: ContentFormat;
-    pages?: string;
-    includeHeaderFooter?: boolean;
-    inlineImages?: boolean;
-    out?: string;
-    force?: boolean;
-    quiet?: boolean;
-}
-/**
- * Pure orchestration for `docs content`: takes an already-fetched
- * Document plus user flags, produces the rendered output, and routes it
- * through the supplied IO surface. Everything between the HTTP fetch
- * and the side-effecting IO lives here so it can be tested without
- * spawning the CLI binary.
- */
-export declare function runDocsContent(args: RunContentArgs, io?: ContentIO): void;

package/dist/docs/content.js

@@ -1,90 +0,0 @@
-import { writeFileSync, existsSync } from 'node:fs';
-import { serializeJson, serializeMarkdown, serializeText, } from '@wafflebase/docs';
-import { FontkitMeasurer } from './fontkit-measurer.js';
-import { parsePageRange } from './page-range.js';
-import { sliceBlocksByPages } from './page-slice.js';
-import { paginateForCli } from './paginate.js';
-export const VALID_CONTENT_FORMATS = ['json', 'md', 'text'];
-export const LOSSY_NOTICE = 'Lossy conversion: see docs-cli design for the exact mapping';
-export const PAGES_FONT_WARNING = 'Note: --pages uses approximate pagination (no document fonts loaded). ' +
-    'Page boundaries may drift on CJK or font-heavy documents — ' +
-    'use `docs export pdf --pages` for exact subsets.';
-export function parseContentFormat(value) {
-    if (!VALID_CONTENT_FORMATS.includes(value)) {
-        throw new Error(`Invalid --format "${value}". Use one of: ${VALID_CONTENT_FORMATS.join(', ')}.`);
-    }
-    return value;
-}
-export const defaultIO = {
-    stdout: (text) => {
-        process.stdout.write(text);
-        if (!text.endsWith('\n'))
-            process.stdout.write('\n');
-    },
-    stderr: (line) => {
-        console.error(line);
-    },
-    writeFile: (path, text, force) => {
-        if (existsSync(path) && !force) {
-            throw new Error(`Refusing to overwrite "${path}". Pass --force to allow overwrite.`);
-        }
-        writeFileSync(path, text.endsWith('\n') ? text : text + '\n', 'utf-8');
-    },
-};
-/**
- * Pure orchestration for `docs content`: takes an already-fetched
- * Document plus user flags, produces the rendered output, and routes it
- * through the supplied IO surface. Everything between the HTTP fetch
- * and the side-effecting IO lives here so it can be tested without
- * spawning the CLI binary.
- */
-export function runDocsContent(args, io = defaultIO) {
-    const { format, pages, includeHeaderFooter = false, inlineImages = false, out, force = false, quiet = false, } = args;
-    let working = args.doc;
-    let layout;
-    if (pages) {
-        const measurer = new FontkitMeasurer();
-        // `docs content --pages` paginates with a font-less measurer, so
-        // every glyph falls back to the 0.5em estimate. That's accurate
-        // enough for ASCII-heavy docs but underestimates CJK by ~50% and
-        // mis-sizes narrow glyphs (`i`, `:`, `.`) — page boundaries can
-        // drift by ±1 page on real documents. `docs export pdf` doesn't
-        // suffer from this because PdfPainter does its own measurement at
-        // paint time. Pre-loading document fonts here is tracked as a
-        // follow-up; until then we surface the limitation on stderr.
-        if (!quiet) {
-            io.stderr(PAGES_FONT_WARNING);
-        }
-        const fullLayout = paginateForCli(working, measurer);
-        const range = parsePageRange(pages, fullLayout.pages.length);
-        if (!quiet) {
-            for (const w of range.warnings)
-                io.stderr(w);
-        }
-        const slice = sliceBlocksByPages(working, fullLayout, range, format);
-        working = { ...working, blocks: slice.blocks };
-        layout = fullLayout;
-    }
-    if (format === 'md' && !quiet) {
-        io.stderr(LOSSY_NOTICE);
-    }
-    let text;
-    switch (format) {
-        case 'json':
-            text = JSON.stringify(serializeJson(working, layout), null, 2);
-            break;
-        case 'md':
-            text = serializeMarkdown(working, { includeHeaderFooter, inlineImages });
-            break;
-        case 'text':
-            text = serializeText(working, { includeHeaderFooter });
-            break;
-    }
-    if (!out || out === '-') {
-        io.stdout(text);
-        return;
-    }
-    io.writeFile(out, text, force);
-    if (!quiet)
-        io.stderr(`Wrote to ${out}`);
-}

package/dist/docs/docx-export.d.ts

@@ -1,23 +0,0 @@
-import { type Document, type DocxImageFetcher } from '@wafflebase/docs';
-export interface CliDocxExportOptions {
-    /** Mirrors `--include-header-footer`; informational only — DOCX always
-     *  emits the document's `header` / `footer` regions when they exist. */
-    includeHeaderFooter?: boolean;
-    /** Test seam: provide a stub image fetcher so `exportDocx` doesn't
-     *  reach out to the network for image inlines. The aliased
-     *  `DocxImageFetcher` (vs. the bare `ImageFetcher`) survives the
-     *  Node-bundle resolution path; the bare alias only exists on the
-     *  browser bundle, so importing it would silently break under any TS
-     *  config that prefers the `node` exports condition. */
-    imageFetcher?: DocxImageFetcher;
-}
-/**
- * Render `doc` to a `.docx` byte buffer via the shared `DocxExporter`.
- *
- * `--pages` is intentionally not handled here — the design (§5.2) says
- * the docx path warns and ignores it; the CLI command emits that
- * warning before calling this function so the helper itself stays a
- * pure renderer. Throws if the document contains image inlines and no
- * `imageFetcher` is supplied (matching `DocxExporter.export` behavior).
- */
-export declare function exportDocx(doc: Document, opts?: CliDocxExportOptions): Promise<Uint8Array>;

package/dist/docs/docx-export.js

@@ -1,14 +0,0 @@
-import { DocxExporter, } from '@wafflebase/docs';
-/**
- * Render `doc` to a `.docx` byte buffer via the shared `DocxExporter`.
- *
- * `--pages` is intentionally not handled here — the design (§5.2) says
- * the docx path warns and ignores it; the CLI command emits that
- * warning before calling this function so the helper itself stays a
- * pure renderer. Throws if the document contains image inlines and no
- * `imageFetcher` is supplied (matching `DocxExporter.export` behavior).
- */
-export async function exportDocx(doc, opts = {}) {
-    const blob = await DocxExporter.export(doc, opts.imageFetcher);
-    return new Uint8Array(await blob.arrayBuffer());
-}

package/dist/docs/docx-import.d.ts

@@ -1,36 +0,0 @@
-import './dom-polyfill.js';
-import { type Document, type ImageUploader } from '@wafflebase/docs';
-/**
- * Default `ImageUploader` for the CLI: encodes each image inline as a
- * `data:` URL. The Yorkie store treats inline-image `src` values as
- * opaque strings, so a self-contained data URL round-trips cleanly
- * without needing a backend image upload endpoint.
- *
- * The MIME type is derived from the filename's extension (matching what
- * `DocxImporter` infers from `.rels` content types). Unknown
- * extensions fall back to `application/octet-stream` — pdf-lib /
- * browser image rendering will refuse to display those, but at least
- * the document round-trip stays lossless at the JSON layer.
- */
-export declare const inlineBase64Uploader: ImageUploader;
-export interface CliDocxImportOptions {
-    /** Override the default base64 uploader — primarily for tests. */
-    imageUploader?: ImageUploader;
-}
-/**
- * Parse a .docx byte buffer into a `Document` using the editor's
- * `DocxImporter`. The polyfill side-effect import at the top of this
- * file installs `DOMParser` from `@xmldom/xmldom` so the importer's
- * browser-targeted XML parsing works in Node.
- *
- * Throws a wrapped `INVALID_DOCX` error when the underlying importer
- * cannot make sense of the buffer (missing `word/document.xml`,
- * malformed XML, unsupported zip layout). The CLI command translates
- * the wrapper into the documented `{ error.code: 'INVALID_DOCX' }`
- * exit body without leaking implementation details.
- */
-export declare function importDocx(buf: Uint8Array, opts?: CliDocxImportOptions): Promise<Document>;
-export declare class InvalidDocxError extends Error {
-    readonly code = "INVALID_DOCX";
-    constructor(message: string);
-}

package/dist/docs/docx-import.js

@@ -1,70 +0,0 @@
-import './dom-polyfill.js';
-import { DocxImporter, } from '@wafflebase/docs';
-/**
- * Default `ImageUploader` for the CLI: encodes each image inline as a
- * `data:` URL. The Yorkie store treats inline-image `src` values as
- * opaque strings, so a self-contained data URL round-trips cleanly
- * without needing a backend image upload endpoint.
- *
- * The MIME type is derived from the filename's extension (matching what
- * `DocxImporter` infers from `.rels` content types). Unknown
- * extensions fall back to `application/octet-stream` — pdf-lib /
- * browser image rendering will refuse to display those, but at least
- * the document round-trip stays lossless at the JSON layer.
- */
-export const inlineBase64Uploader = async (blob, filename) => {
-    const arrayBuf = await blob.arrayBuffer();
-    const base64 = Buffer.from(arrayBuf).toString('base64');
-    const mime = blob.type || mimeFromFilename(filename) || 'application/octet-stream';
-    return `data:${mime};base64,${base64}`;
-};
-function mimeFromFilename(filename) {
-    const dot = filename.lastIndexOf('.');
-    if (dot < 0)
-        return undefined;
-    const ext = filename.slice(dot + 1).toLowerCase();
-    switch (ext) {
-        case 'png':
-            return 'image/png';
-        case 'jpg':
-        case 'jpeg':
-            return 'image/jpeg';
-        case 'gif':
-            return 'image/gif';
-        case 'webp':
-            return 'image/webp';
-        case 'bmp':
-            return 'image/bmp';
-        default:
-            return undefined;
-    }
-}
-/**
- * Parse a .docx byte buffer into a `Document` using the editor's
- * `DocxImporter`. The polyfill side-effect import at the top of this
- * file installs `DOMParser` from `@xmldom/xmldom` so the importer's
- * browser-targeted XML parsing works in Node.
- *
- * Throws a wrapped `INVALID_DOCX` error when the underlying importer
- * cannot make sense of the buffer (missing `word/document.xml`,
- * malformed XML, unsupported zip layout). The CLI command translates
- * the wrapper into the documented `{ error.code: 'INVALID_DOCX' }`
- * exit body without leaking implementation details.
- */
-export async function importDocx(buf, opts = {}) {
-    const arrayBuf = buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
-    try {
-        return await DocxImporter.import(arrayBuf, opts.imageUploader ?? inlineBase64Uploader);
-    }
-    catch (e) {
-        const message = e instanceof Error ? e.message : String(e);
-        throw new InvalidDocxError(message);
-    }
-}
-export class InvalidDocxError extends Error {
-    code = 'INVALID_DOCX';
-    constructor(message) {
-        super(message);
-        this.name = 'InvalidDocxError';
-    }
-}

package/dist/docs/dom-polyfill.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/docs/dom-polyfill.js

@@ -1,29 +0,0 @@
-import { DOMParser as XmldomParser } from '@xmldom/xmldom';
-/**
- * Make `DOMParser` available globally so `@wafflebase/docs`'s
- * `DocxImporter` can call `new DOMParser()` from a Node CLI process.
- *
- * `DocxImporter` was originally written for the browser and parses
- * `.docx` XML through the WHATWG DOMParser. Node has no built-in DOM,
- * so we substitute `@xmldom/xmldom`'s implementation — it's an XML-only
- * parser (no HTML quirks, no full DOM tree mutation) but covers the
- * `getElementsByTagNameNS` / `textContent` / `getAttribute` surface the
- * importer actually touches.
- *
- * The shim is idempotent: if a real `DOMParser` is already present
- * (jsdom-environment tests, future Node releases that ship one) we
- * leave it alone so production code continues to use the more featureful
- * implementation.
- *
- * Side-effect import — bring this file in *before* any code path that
- * calls `DocxImporter.import`.
- */
-const g = globalThis;
-if (typeof g.DOMParser === 'undefined') {
-    // Assign through an `unknown` cast because `@xmldom/xmldom`'s
-    // `DOMParser` shape is a runtime superset of WHATWG's but uses its
-    // own type declarations. `DocxImporter` only consumes the XML subset
-    // both implementations share, so the runtime contract holds even
-    // though the static types don't unify.
-    g.DOMParser = XmldomParser;
-}

package/dist/docs/fontkit-measurer.d.ts

@@ -1,41 +0,0 @@
-import { Buffer } from 'node:buffer';
-import type { TextMeasurer, ResolvedFont } from '@wafflebase/docs';
-export interface FontkitMeasurerOptions {
-    /**
-     * Width per character in em-units used when no font is registered for
-     * the requested variant. Multiplied by `font.size` to produce a px value.
-     * Defaults to `0.5` — a coarse proportional-font approximation that
-     * keeps pagination from collapsing to zero when a font is missing.
-     *
-     * Callers that pre-load every font referenced by a document never hit
-     * this path; the fallback exists so a single missing variant does not
-     * crash the CLI mid-pagination.
-     */
-    fallbackEmWidth?: number;
-}
-/**
- * `TextMeasurer` backed by `fontkit` for use in Node CLI contexts where
- * no Canvas 2D API is available. Width is computed as
- * `glyphRun.advanceWidth ÷ unitsPerEm × size` for each registered font.
- *
- * Measurement is synchronous; callers must `register()` every font
- * variant they need *before* invoking `paginateLayout` / `measureWidth`.
- * Loading is async (file/network IO) but the layout pipeline is not, so
- * we split the two phases.
- */
-export declare class FontkitMeasurer implements TextMeasurer {
-    private readonly fonts;
-    private readonly fallbackEmWidth;
-    constructor(opts?: FontkitMeasurerOptions);
-    /**
-     * Register a font buffer for a specific variant. Subsequent
-     * `measureWidth` calls whose `(family, weight, style)` matches will use
-     * this font's metrics. A `FontCollection` (.ttc) input is rejected
-     * here — the caller must pick the desired face out of the collection
-     * first to keep the cache key unambiguous.
-     */
-    register(family: string, weight: ResolvedFont['weight'], style: ResolvedFont['style'], buffer: Uint8Array | ArrayBuffer | Buffer): void;
-    /** True when the variant has a registered font (no fallback path). */
-    has(family: string, weight: ResolvedFont['weight'], style: ResolvedFont['style']): boolean;
-    measureWidth(text: string, font: ResolvedFont): number;
-}

package/dist/docs/fontkit-measurer.js

@@ -1,64 +0,0 @@
-import { Buffer } from 'node:buffer';
-import * as fontkit from 'fontkit';
-/**
- * Variant key for the in-memory font cache. Lowercased family name plus
- * weight/style ensures `'Helvetica'` and `'helvetica'` resolve to the same
- * registered buffer — Canvas measurement is case-insensitive on family
- * lookups, so we mirror that here so the CLI matches browser pagination.
- */
-function variantKey(family, weight, style) {
-    return `${family.toLowerCase()}|${weight}|${style}`;
-}
-/**
- * `TextMeasurer` backed by `fontkit` for use in Node CLI contexts where
- * no Canvas 2D API is available. Width is computed as
- * `glyphRun.advanceWidth ÷ unitsPerEm × size` for each registered font.
- *
- * Measurement is synchronous; callers must `register()` every font
- * variant they need *before* invoking `paginateLayout` / `measureWidth`.
- * Loading is async (file/network IO) but the layout pipeline is not, so
- * we split the two phases.
- */
-export class FontkitMeasurer {
-    fonts = new Map();
-    fallbackEmWidth;
-    constructor(opts = {}) {
-        this.fallbackEmWidth = opts.fallbackEmWidth ?? 0.5;
-    }
-    /**
-     * Register a font buffer for a specific variant. Subsequent
-     * `measureWidth` calls whose `(family, weight, style)` matches will use
-     * this font's metrics. A `FontCollection` (.ttc) input is rejected
-     * here — the caller must pick the desired face out of the collection
-     * first to keep the cache key unambiguous.
-     */
-    register(family, weight, style, buffer) {
-        const buf = toBuffer(buffer);
-        const parsed = fontkit.create(buf);
-        if ('fonts' in parsed) {
-            throw new Error(`FontkitMeasurer.register("${family}"): TrueType collections (.ttc) ` +
-                `must be split into individual faces before registration.`);
-        }
-        this.fonts.set(variantKey(family, weight, style), parsed);
-    }
-    /** True when the variant has a registered font (no fallback path). */
-    has(family, weight, style) {
-        return this.fonts.has(variantKey(family, weight, style));
-    }
-    measureWidth(text, font) {
-        if (text.length === 0)
-            return 0;
-        const f = this.fonts.get(variantKey(font.family, font.weight, font.style));
-        if (!f)
-            return text.length * this.fallbackEmWidth * font.size;
-        const run = f.layout(text);
-        return (run.advanceWidth / f.unitsPerEm) * font.size;
-    }
-}
-function toBuffer(input) {
-    if (Buffer.isBuffer(input))
-        return input;
-    if (input instanceof ArrayBuffer)
-        return Buffer.from(new Uint8Array(input));
-    return Buffer.from(input);
-}

package/dist/docs/image-fetcher.d.ts

@@ -1,37 +0,0 @@
-import type { DocxImageFetcher } from '@wafflebase/docs';
-export interface ImageFetcherOptions {
-    /**
-     * Base URL of the Wafflebase API server. Used to resolve image
-     * inlines whose `src` is a server-relative path (`/images/<id>`).
-     * Absolute URLs (`http(s)://...`, `data:`, `blob:`, ...) pass through
-     * untouched so docs imported from external sources keep working.
-     */
-    serverBase: string;
-    /**
-     * Optional `fetch` override — kept as a seam for tests. Defaults to
-     * the global `fetch`. The signature matches the WHATWG fetch so a
-     * stub can be a plain async function without pulling DOM types in.
-     */
-    fetch?: typeof globalThis.fetch;
-}
-/**
- * Resolve a possibly-relative image URL against the configured server
- * base. Mirrors `resolveImageUrl` in
- * `packages/frontend/src/app/docs/export-utils.ts` so the CLI and
- * browser agree on what counts as "absolute". The shared rule: any URL
- * that starts with a scheme (`http:`, `https:`, `data:`, `blob:`,
- * `file:`, ...) is left alone; everything else gets prefixed.
- */
-export declare function resolveImageUrl(url: string, serverBase: string): string;
-/**
- * Build an `ImageFetcher` for the CLI export pipelines. The fetcher
- * downloads each unique image inline `src` once, returning a Blob the
- * exporter can embed verbatim (PDF) or stream into the DOCX zip.
- *
- * Backend's `GET /images/:id` is publicly readable, so we don't attach
- * an Authorization header — sending JWT cookies via the CLI isn't
- * possible anyway. Relative URLs resolve against `serverBase`; absolute
- * URLs (e.g., the canonical `https://api.wafflebase.io/images/...`
- * surfaced by `imageFetcher required` errors) pass through.
- */
-export declare function createImageFetcher(opts: ImageFetcherOptions): DocxImageFetcher;

package/dist/docs/image-fetcher.js

@@ -1,38 +0,0 @@
-/**
- * Resolve a possibly-relative image URL against the configured server
- * base. Mirrors `resolveImageUrl` in
- * `packages/frontend/src/app/docs/export-utils.ts` so the CLI and
- * browser agree on what counts as "absolute". The shared rule: any URL
- * that starts with a scheme (`http:`, `https:`, `data:`, `blob:`,
- * `file:`, ...) is left alone; everything else gets prefixed.
- */
-export function resolveImageUrl(url, serverBase) {
-    if (/^[a-z][a-z0-9+.-]*:/i.test(url))
-        return url;
-    const base = serverBase.replace(/\/$/, '');
-    if (!base)
-        return url;
-    return `${base}${url.startsWith('/') ? url : `/${url}`}`;
-}
-/**
- * Build an `ImageFetcher` for the CLI export pipelines. The fetcher
- * downloads each unique image inline `src` once, returning a Blob the
- * exporter can embed verbatim (PDF) or stream into the DOCX zip.
- *
- * Backend's `GET /images/:id` is publicly readable, so we don't attach
- * an Authorization header — sending JWT cookies via the CLI isn't
- * possible anyway. Relative URLs resolve against `serverBase`; absolute
- * URLs (e.g., the canonical `https://api.wafflebase.io/images/...`
- * surfaced by `imageFetcher required` errors) pass through.
- */
-export function createImageFetcher(opts) {
-    const fetchImpl = opts.fetch ?? globalThis.fetch;
-    return async (url) => {
-        const resolved = resolveImageUrl(url, opts.serverBase);
-        const res = await fetchImpl(resolved);
-        if (!res.ok) {
-            throw new Error(`Image fetch failed: ${res.status} ${res.statusText} for ${resolved}`);
-        }
-        return res.blob();
-    };
-}

package/dist/docs/import.d.ts

@@ -1,72 +0,0 @@
-import type { Document, ImageUploader } from '@wafflebase/docs';
-/**
- * Minimal HTTP surface `runDocsImport` needs from the CLI's
- * `HttpClient`. Spelled out so tests can pass a stub without depending
- * on the full client.
- */
-export interface ImportClient {
-    createDocument: (title: string, type?: 'doc' | 'sheet') => Promise<{
-        ok: boolean;
-        status: number;
-        data: unknown;
-    }>;
-    putDocContent: (docId: string, doc: Document) => Promise<{
-        ok: boolean;
-        status: number;
-        data: unknown;
-    }>;
-}
-export interface ImportIO {
-    /** Final structured payload — written to stdout as JSON. */
-    stdout: (line: string) => void;
-    stderr: (line: string) => void;
-    /**
-     * Read the docx bytes for `path`. `'-'` reads from stdin.
-     *
-     * Split out so tests can inject in-memory buffers without juggling
-     * tmp files; the default reads `process.stdin` (or the file
-     * synchronously) at the action site.
-     */
-    readBytes: (path: string) => Promise<Uint8Array>;
-    /**
-     * Prompt the user for a yes/no answer when running interactively.
-     * Returns `true` for affirmative responses (case-insensitive `y` /
-     * `yes`); anything else (including end-of-stream) → `false`.
-     */
-    confirm: (prompt: string) => Promise<boolean>;
-    /** Whether the current process is interactive (a TTY on stdin).   *  Tests inject `false` to exercise the non-interactive branches. */
-    isTTY: boolean;
-}
-export declare const defaultImportIO: ImportIO;
-export interface RunImportArgs {
-    /** Source path. `'-'` reads from stdin. */
-    file: string;
-    /** Override the doc title. Falls back to the file basename. */
-    title?: string;
-    /** Existing document ID to overwrite. Pairs with `--yes`. */
-    replace?: string;
-    /** Skip the interactive `--replace` confirmation. */
-    yes?: boolean;
-    /** Override the default base64 image uploader. Tests pass a no-op. */
-    imageUploader?: ImageUploader;
-    /** Suppress informational stderr output (errors still reported). */
-    quiet?: boolean;
-    /** Print the request that *would* fire instead of issuing it. */
-    dryRun?: boolean;
-}
-export interface RunImportResult {
-    /** Process exit code. The action sets `process.exitCode` accordingly. */
-    exitCode: number;
-}
-/**
- * Pure orchestration for `docs import`. Reads the source `.docx`,
- * parses it into a `Document`, then either creates a new document
- * (default) or overwrites an existing one (`--replace`).
- *
- * Why split out from the command action: the action's layered handling
- * of stdin / TTY / interactive prompt is the easiest path to test
- * regressions in. Mocking `process.stdin` at the harness level is
- * fragile; passing in an `ImportIO` lets us drive every branch
- * deterministically.
- */
-export declare function runDocsImport(args: RunImportArgs, client: ImportClient, io?: ImportIO): Promise<RunImportResult>;