tachlon 0.0.1 → 0.1.0

package/dist-lib/tachlon.js

@@ -0,0 +1 @@
+export { r as MountError, a as PRODUCT_NAME, s as PlainDataError, n as fromBryntum, l as fromDhtmlx, o as fromTasks, t as mount, i as preloadEngine, c as validate } from "./src-CTpvK70m.js";

package/dist-lib/types/adapters/bryntum.d.ts

@@ -0,0 +1,68 @@
+/** One task of the document, in the shape `App.save` writes (version 1). */
+export interface DocumentTask {
+    /** Working minutes of the task's calendar. */
+    duration: number;
+    calendar: number;
+    /** Earliest start, minutes from the origin Monday 00:00; null for none. */
+    snet: number | null;
+    actual_start: number | null;
+    actual_finish: number | null;
+    remaining: number | null;
+    name: string;
+    /** The index in `tasks` of the parent, or null for a top-level task. */
+    parent: number | null;
+    /** 1 for a top-level task. */
+    outline_level: number;
+    code: string | null;
+    wbs_code: string | null;
+    activity_codes: [string, string][];
+    /** Percent complete, 0 to 100. */
+    progress: number;
+}
+/** One link of the document, between two indexes of `tasks`. */
+export interface DocumentLink {
+    pred: number;
+    succ: number;
+    kind: "FS" | "SS" | "FF" | "SF";
+    /** Working minutes; negative for a lead. */
+    lag: number;
+    lag_calendar: null;
+}
+/** The document (version 1) with the keys the adapter fills; `Gantt.load({ document })` takes it. */
+export interface ScheduleDocument {
+    format: "gantt";
+    version: 1;
+    name: string;
+    /** Days from 1970-01-01 to the Monday that is instant 0. */
+    origin: number;
+    data_date: null;
+    lag_calendar: "successor";
+    calendars: {
+        week: [number, number][][];
+        exceptions: [];
+    }[];
+    tasks: DocumentTask[];
+    links: DocumentLink[];
+    baseline: null;
+    view: {
+        collapsed: [];
+    };
+    /** The lines of `leftOut`, which the chart shows as its import notes. */
+    notes: string[];
+    source: null;
+}
+/** What `fromBryntum` returns: the document and one line for each thing in the data it could not carry, or why there is no document. */
+export type BryntumResult = {
+    ok: true;
+    document: ScheduleDocument;
+    leftOut: string[];
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * Read Bryntum Gantt data into the document. `data` is what a Bryntum project loads: `{ tasks, dependencies }`, each
+ * a `{ rows: [...] }` store or an array (`tasksData` and `dependenciesData` are read too). A task is nested under its
+ * `children` or tied to its parent by `parentId`. Never throws: data with no task list gives `{ ok: false, error }`.
+ */
+export declare function fromBryntum(data: unknown): BryntumResult;

package/dist-lib/types/adapters/dhtmlx.d.ts

@@ -0,0 +1,96 @@
+/** A task of DHTMLX data. Only the fields named here are read; any other field is listed in `leftOut`. */
+export interface DhtmlxTask {
+    id: string | number;
+    text?: string;
+    start_date?: string;
+    end_date?: string;
+    duration?: number | string;
+    progress?: number | string;
+    parent?: string | number;
+    type?: string;
+    [field: string]: unknown;
+}
+/** A link of DHTMLX data: `type` is `"0"` finish to start, `"1"` start to start, `"2"` finish to finish, `"3"` start to finish. */
+export interface DhtmlxLink {
+    id?: string | number;
+    source: string | number;
+    target: string | number;
+    type?: string | number;
+    lag?: number | string;
+    [field: string]: unknown;
+}
+/** The JSON DHTMLX Gantt loads: the tasks and the links. */
+export interface DhtmlxData {
+    data: DhtmlxTask[];
+    links?: DhtmlxLink[];
+}
+/** What `fromDhtmlx` takes beside the data. */
+export interface DhtmlxOptions {
+    /** The schedule's name. Default `untitled`. */
+    name?: string;
+    /** The unit of the data's `duration` and `lag` (DHTMLX `duration_unit`): `day` (default) is a working day of 8 hours, `hour` an hour. */
+    durationUnit?: "day" | "hour";
+    /** The word the `leftOut` lines open with, naming where the data came from. Default `DHTMLX`. */
+    label?: string;
+}
+/** A task of the document. */
+export interface DocumentTask {
+    duration: number;
+    calendar: number;
+    snet: number | null;
+    actual_start: null;
+    actual_finish: null;
+    remaining: null;
+    name: string;
+    parent: number | null;
+    outline_level: number;
+    code: string | null;
+    wbs_code: null;
+    activity_codes: [];
+    progress: number;
+}
+/** A link of the document. */
+export interface DocumentLink {
+    pred: number;
+    succ: number;
+    kind: "FS" | "SS" | "FF" | "SF";
+    lag: number;
+    lag_calendar: null;
+}
+/** The document v1 that `fromDhtmlx` writes: keys in the order the writer uses. */
+export interface ScheduleDocument {
+    format: "gantt";
+    version: 1;
+    name: string;
+    origin: number;
+    data_date: null;
+    lag_calendar: "successor";
+    calendars: {
+        week: [number, number][][];
+        exceptions: [];
+    }[];
+    tasks: DocumentTask[];
+    links: DocumentLink[];
+    baseline: null;
+    view: {
+        collapsed: [];
+    };
+    notes: string[];
+    source: null;
+}
+/** What `fromDhtmlx` returns: the document, and one line for each thing of the data it did not carry over (also in `document.notes`). */
+export interface DhtmlxResult {
+    document: ScheduleDocument;
+    leftOut: string[];
+}
+export declare const DAY = 1440;
+export declare const WORKING_DAY = 480;
+/** Working time of the one calendar: Monday to Friday, 08:00 to 12:00 and 13:00 to 17:00. */
+export declare const WORKING_WEEK: [number, number][][];
+/** Minutes since 1970-01-01 00:00 of the wall-clock time `text` names, or null. Reads `YYYY-MM-DD[ T]HH:mm[:ss]` (a trailing `Z` is not converted) and `DD-MM-YYYY[ HH:mm]`. */
+export declare function minutesOf(text: string): number | null;
+/** The `leftOut` lines for the unread fields in `counts` (field to the number of items that carry it), by field name. */
+export declare function unreadLines(counts: Map<string, number>, what: string, label: string): string[];
+export declare function plural(count: number, one: string, many: string): string;
+/** Read DHTMLX Gantt JSON into a document v1. Throws an `Error` whose message names the task or link it could not read. */
+export declare function fromDhtmlx(source: unknown, options?: DhtmlxOptions): DhtmlxResult;

package/dist-lib/types/adapters/index.d.ts

@@ -0,0 +1,7 @@
+export { fromDhtmlx } from "./dhtmlx.js";
+export type { DhtmlxOptions, DhtmlxResult } from "./dhtmlx.js";
+export { fromTasks } from "./plain.js";
+export type { PlainLink, PlainOptions, PlainResult, PlainTask } from "./plain.js";
+export { PlainDataError, validate } from "./validate.js";
+export type { PlainIssue, PlainValidation } from "./validate.js";
+export { fromBryntum, type BryntumResult, type ScheduleDocument } from "./bryntum.js";

package/dist-lib/types/adapters/plain.d.ts

@@ -0,0 +1,35 @@
+import { type ScheduleDocument } from "./dhtmlx.ts";
+/** A task: `start` and `end` are `YYYY-MM-DD[THH:mm]`, `duration` is in working days, `progress` 0 to 100. A task with children is a summary that takes its dates from them. */
+export interface PlainTask {
+    id: string | number;
+    name: string;
+    start: string;
+    end?: string;
+    duration?: number;
+    parent?: string | number;
+    progress?: number;
+    [field: string]: unknown;
+}
+/** A link from one task to another: `type` defaults to `FS` (finish to start), `lag` is in working days. */
+export interface PlainLink {
+    from: string | number;
+    to: string | number;
+    type?: "FS" | "SS" | "FF" | "SF";
+    lag?: number;
+    [field: string]: unknown;
+}
+/** What `fromTasks` takes beside the data. */
+export interface PlainOptions {
+    /** The schedule's name. Default `untitled`. */
+    name?: string;
+}
+/** What `fromTasks` returns: the document, and one line for each thing of the data it did not carry over (also in `document.notes`). */
+export interface PlainResult {
+    document: ScheduleDocument;
+    leftOut: string[];
+}
+/** Read plain tasks and links into a document v1. Throws a `PlainDataError` that lists every problem (see `validate`) before it reads anything. */
+export declare function fromTasks(data: {
+    tasks: PlainTask[];
+    links?: PlainLink[];
+}, options?: PlainOptions): PlainResult;

package/dist-lib/types/adapters/validate.d.ts

@@ -0,0 +1,26 @@
+/** One problem: `path` is like `tasks[0].start`; `fix` is a sentence a person or an assistant can act on. */
+export interface PlainIssue {
+    path: string;
+    expected: string;
+    got: string;
+    fix: string;
+}
+/** What `validate` returns: `{ ok: true }`, or every problem, up to 50. */
+export type PlainValidation = {
+    ok: true;
+} | {
+    ok: false;
+    issues: PlainIssue[];
+};
+/** What `fromTasks` throws for data `validate` refuses; `issues` is the list, `message` is the list as lines. */
+export declare class PlainDataError extends Error {
+    readonly issues: PlainIssue[];
+    constructor(issues: PlainIssue[]);
+}
+/** Check plain task data and name every problem, up to 50. */
+export declare function validate(data: unknown): PlainValidation;
+/** `validate`'s one walk of the data: the problems, and the index of each task by `String(id)` for the reader to use. */
+export declare function inspect(data: unknown): {
+    issues: PlainIssue[];
+    ids: Map<string, number>;
+};

package/dist-lib/types/api.d.ts

@@ -0,0 +1,207 @@
+import type { ZoomLevel } from "./view-state.js";
+/** What `App.status()` returns. */
+export interface Status {
+    backend: string;
+    /** Total task count, including tasks hidden by collapsed summaries. */
+    n: number;
+    /** Number of visible task rows. */
+    rowCount: number;
+    /** The leaf tasks the row filter and the lookahead window keep (collapse does not change it), or null while neither is on. */
+    keptLeaves: number | null;
+    /** Whether the critical-only filter is on. */
+    criticalOnly: boolean;
+    /** Whether the longest-path filter is on. */
+    longestPath: boolean;
+    filter: "off" | "critical" | "longest" | "slipped" | "joined" | "left" | "code" | "moved" | "near" | "status" | "float";
+    /** The lookahead window: `start` as `YYYY-MM-DD`. When `on` is false these are the defaults a reader gets (the data date's day, 3 weeks). */
+    lookahead: {
+        on: boolean;
+        start: string;
+        weeks: number;
+    };
+    rows: [number, number];
+    t: [number, number];
+    from: string;
+    to: string;
+    /** The time axis's unit at the current zoom (`timeline::Level::name`). */
+    level: ZoomLevel;
+    pxPerMinute: number;
+    scrollY: number;
+    rowHeight: number;
+    axisHeight: number;
+    bars: number;
+    criticalBars: number;
+    /** Dependency arrows drawn this frame. */
+    arrows: number;
+    /** Non-working-day columns drawn this frame. */
+    shaded: number;
+    /** The file's data date in minutes from the origin Monday, or null if it has none. */
+    dataDate: number | null;
+    /** x of the data-date line on the canvas in CSS pixels, or null when it is not drawn. */
+    dataDateX: number | null;
+    /** Counts the changes the schedule has had; a drag that ends where it began leaves it as it was. */
+    revision: number;
+    /** Counts the solutions shown, restores included; the table redraws its rows when it moves. */
+    stamp: number;
+    /** Counts the files opened in place; the shell resets what it keeps for the old schedule when it moves. */
+    epoch: number;
+    frames: number;
+    surface: [number, number];
+    hover: Hover | null;
+    /** The row the canvas draws as hovered: under its own pointer, else the one `set_hover_row` named; null if none. */
+    hoverRow: number | null;
+    drag: Drag | null;
+    selected: Selected | null;
+    /** The range selection as table rows `[first, last, extent]`: `first` to `last` inclusive, `extent` the end that moves; null with no range. */
+    range: [number, number, number] | null;
+    link: Link;
+    /** How the schedule differs from the baseline, or null with no baseline set. */
+    baseline: BaselineSummary | null;
+    /** The report of the last edit or drag release that moved other tasks, or null. */
+    moved: Moved | null;
+    /** The slide of the bars after an edit: whether one runs, and how long its copy took. */
+    slide: SlideStatus;
+    /** The nearest work before and after the window, as short dates, when no visible row has work in it; else null. */
+    offscreen: {
+        b: string | null;
+        a: string | null;
+    } | null;
+}
+/** The slide of the bars to their new places after an edit. */
+export interface SlideStatus {
+    /** True while a slide runs. Never true while the page asked for reduced motion. */
+    active: boolean;
+    /** How long the copy of the last slide took, in milliseconds; null before the first slide. It stays after the slide ends. */
+    copyMs: number | null;
+}
+/** How the schedule differs from the baseline, as counts. A task counts only if it is live now and was live in the baseline, except `added` and `removed`. */
+export interface BaselineSummary {
+    /** Tasks whose early finish is later than the baseline's. */
+    slipped: number;
+    /** Calendar days the project finish moved; negative when earlier. */
+    finish_days: number;
+    /** Tasks that have zero float now and had some in the baseline. */
+    joined: number;
+    /** Tasks that had zero float in the baseline and have some now. */
+    left: number;
+    /** Live tasks the baseline has no entry for (inserted since). */
+    added: number;
+    /** Tasks the baseline holds that are deleted now. */
+    removed: number;
+}
+/** What an edit or a drag moved besides the edited task. */
+export interface Moved {
+    /** Counts reports, so a new one differs from the one already shown. */
+    seq: number;
+    /** For example `8 tasks moved · finish +7 days`. */
+    text: string;
+    /** Tasks other than the edited one whose early start or finish changed. */
+    others: number;
+    /** Calendar days the project finish moved; negative when earlier. */
+    finish_days: number;
+    /** 1 while the report is fully shown, then falls to 0 as it fades. */
+    alpha: number;
+    /** True for an edit, false for a drag release whose bars are already where the pointer left them. */
+    slide: boolean;
+}
+/** The selected link, the link drag in progress, and why the last link drag added nothing. */
+export interface Link {
+    /** The selected link's id (a dependency slot), or null. */
+    selected: number | null;
+    /** A link drag that has moved past the threshold, or null. */
+    drag: LinkDrag | null;
+    /** The message the last link drag was refused with, until the next press; null if it was not refused. */
+    refusal: string | null;
+    /** A calm note about a bar drag that moved nothing (a finished task), until the next press; null if none. */
+    note: string | null;
+}
+/** A link drag in progress, from the bar of task `pred`. */
+export interface LinkDrag {
+    pred: number;
+    /** The task under the pointer, or null. */
+    target: number | null;
+    /** The message a release on `target` would be refused with (a summary, a repeat or a loop), or null. */
+    refused: string | null;
+}
+/** A selected task and counts for its driving path. */
+export interface Selected {
+    /** The selected task. */
+    task: number;
+    /** The selected task's timeline row. */
+    row: number;
+    /** Number of driving predecessors retained. */
+    backCount: number;
+    /** Number of driven successors retained. */
+    forwardCount: number;
+    /** More driving predecessors exist than were retained. */
+    backCapped: boolean;
+    /** More driven successors exist than were retained. */
+    forwardCapped: boolean;
+}
+/** The last bar drag's result. */
+export interface Drag {
+    task: number;
+    /**
+     * First admissible start at or after where the pointer asked, minutes. A
+     * task starts on a working instant; a milestone may also start at the end
+     * of a working period.
+     */
+    wanted: number;
+    /** Start the schedule gave, minutes. */
+    es: number;
+    /** Predecessors hold the task later than the pointer asks. */
+    held: boolean;
+    recomputeMs: number;
+    /** The drag is still in progress. */
+    active: boolean;
+}
+/** The task under the pointer. */
+export interface Hover {
+    task: number;
+    es: number;
+    ef: number;
+    float?: number;
+    critical: boolean;
+    summary?: true;
+}
+/** What `App.task_details()` returns for a scheduled task. */
+export interface TaskDetails {
+    task: number;
+    name: string;
+    outlinePath: string;
+    /** The activity ID; empty when the task has none. */
+    activityId: string;
+    /** `Not started`, `In progress` or `Complete`. */
+    status: string;
+    /** Empty until set. */
+    actualStart: string;
+    /** Empty until set. */
+    actualFinish: string;
+    /** Empty for work not started. */
+    percentComplete: string;
+    start: string;
+    finish: string;
+    lateStart: string;
+    lateFinish: string;
+    floatMinutes: number;
+    floatDays: number;
+    floatHours: number;
+    floatRemMinutes: number;
+    floatText: string;
+    critical: boolean;
+    summary?: boolean;
+    predecessorCount: number;
+    predecessors: string[];
+    successorCount: number;
+    successors: string[];
+    /** The baseline's start date. Written for a leaf with a baseline entry, unless the baseline's date is before the origin. */
+    baselineStart?: string;
+    /** The baseline's finish date; written as `baselineStart` is. */
+    baselineFinish?: string;
+    /** The start and finish variance in working days (`+5d`, `-2d`, `0`), each null when the baseline's date is before the origin. Written for a leaf with a baseline entry. */
+    baselineVariance?: [string | null, string | null];
+}
+/** One table row from `App.table_rows`: task, start, finish, float, critical, and kind (leaf 0, expanded summary 1, collapsed summary 2), then the Start, Finish and Float variance against the baseline as signed working-day text (`+5d`, `-2d`, `0`), or null for a summary, a task the baseline lacks, a session with no baseline, a baseline from a file with no float (the Float cell) or with a date before the origin (that Start or Finish cell) and while a bar is dragged. Duration is read separately. */
+export type TableRow = [number, string, string, number | null, boolean, 0 | 1 | 2, string | null, string | null, string | null];
+/** What `App.print_pages(title, printed_on, page_size?)` returns, where the optional `page_size` is `"letter"` (the default) or `"a4"`: one SVG document per printed page, in page order, at least one. */
+export type PrintPages = string[];

package/dist-lib/types/commands.d.ts

@@ -0,0 +1,76 @@
+import { type Filter } from "./set-filter.js";
+import { type CompareResult, type EditResult, type LinkResult, type RowResult } from "./edit-result.js";
+/** Where `scrollTo` goes: a task's row, or a day (`YYYY-MM-DD`). */
+export type ScrollTarget = {
+    task: number;
+} | {
+    date: string;
+};
+/** What a host page may call to drive the chart. After `Gantt.destroy()` every method does nothing and returns undefined; none throws. */
+export interface Commands {
+    /** Zoom in one step about the middle of the chart. */
+    zoomIn(): void;
+    /** Zoom out one step about the middle of the chart. */
+    zoomOut(): void;
+    /** Show the whole project, as the Fit button does. False, changing nothing, with no task. */
+    fit(): boolean | undefined;
+    /**
+     * Bring a task's row and bar into view (it selects the task), or show a day. False, changing nothing, for a task
+     * that is deleted, unknown or has no row (hidden by a collapsed summary or the row filter), for a day that is not a date, and while a bar is pressed or dragged.
+     */
+    scrollTo(target: ScrollTarget): boolean | undefined;
+    /** The same call as `scrollTo({ task })`: select `task` and bring its row and bar into view, as a click on its row does. False, changing nothing, in the cases `scrollTo({ task })` refuses. */
+    select(task: number): boolean | undefined;
+    /**
+     * Turn a filter on, as the toolbar, the Filters menu and the keys do: a row filter (`"critical"`, `"longestPath"`,
+     * `"nearCritical"`, `"slipped"`, `"floatLost"`, `"joinedCritical"`, `"leftCritical"`, `"moved"`, `{ status }`, `{ code }`) replaces the one that is on, `"off"` turns
+     * the row filter off, and `{ lookahead }` sets or (with null) removes the window, which combines with the row filter. True when
+     * the chart took it, also when it was already so; false, changing nothing, when it refused: no outline, a bar press, a value it
+     * does not know, Slipped, Joined or Left with no baseline, Float lost with no baseline float, Show moved with no move report.
+     */
+    setFilter(filter: Filter): boolean | undefined;
+    /** Turn the row filter and the lookahead window off together, as the Filters menu's Clear does. False when the filters cannot change now. */
+    clearFilters(): boolean | undefined;
+    /** Undo the latest edit. True means an edit was undone; a failure is reported on the console and gives false. */
+    undo(): boolean | undefined;
+    /** Redo the latest undone edit. True means an edit was redone; a failure is reported on the console and gives false. */
+    redo(): boolean | undefined;
+    /**
+     * Search the task names and outline paths for `query` (case-blind; with a row filter or the lookahead window on, only the
+     * shown rows), as the find box does, and return the number of matches. It selects nothing: `findGo` and `findNext` do.
+     * False for a query that is not a string. `findGo` and `findNext` run the last `find`'s query again when the schedule or the
+     * filters changed since (`Status.stamp` moved), so they go only to its matches; the chrome's find box searches through this same call.
+     */
+    find(query: string): number | false | undefined;
+    /** Go to the match after the task last gone to (the first after a `find`), wrapping, and return its index: an insert before that task skips nothing. False with no match, and while busy. */
+    findNext(): number | false | undefined;
+    /** Select match `index` (from 0) of the last `find` and bring its row into view. False for an index outside the matches or not a whole number, and while busy. */
+    findGo(index: number): boolean | undefined;
+    /** Collapse every summary at outline level `level` and deeper (1 is the top), as the toolbar's level buttons do. False, changing nothing, for a level that is not a whole number from 1, with no outline, and while busy. */
+    collapseToLevel(level: number): boolean | undefined;
+    /** Expand every summary. False with no outline, and while busy. */
+    expandAll(): boolean | undefined;
+    /** Insert a task named `New task` below the selected task's subtree (the last top-level row with nothing selected) and select it, as the Insert key does: `{ ok: true, task }`, or `{ ok: false, reason }` changing nothing. One undo step. */
+    insertRow(): RowResult | undefined;
+    /** Delete the selected task (never a selected link), as the Delete key does, and select the next row: `{ ok: true, task }` with the deleted task, or `{ ok: false, reason }` changing nothing. One undo step. */
+    deleteRow(): RowResult | undefined;
+    /** Remove the selected link, as the toolbar's Delete does when a link is selected: `{ ok: true, link }` with the removed link, or `{ ok: false, reason, message }` changing nothing (`"noSelection"` with no link selected). One undo step. */
+    deleteLink(): LinkResult | undefined;
+    /** Move the data date to 00:00 on `day`, written `YYYY-MM-DD`, and recompute, or clear it with null. `{ ok: true }`, or `{ ok: false, reason }` changing nothing (`"badDate"` for any other value). One undo step; the day already in force (`state().dataDate`) changes nothing and records none, even when it is a file's data date that is not the schedule's floor: no floor is set, so a host that wants one sets a different day first. */
+    setDataDate(day: string | null): EditResult | undefined;
+    /** Keep every task's dates as they are now as the baseline, replacing one already set. One undo step. */
+    setBaseline(): EditResult | undefined;
+    /** Drop the baseline. `"noBaseline"` with none. One undo step. */
+    clearBaseline(): EditResult | undefined;
+    /** Give the tasks added since the baseline their current dates as baseline, keeping every other entry. `"noBaseline"` with none. One undo step. */
+    addNewToBaseline(): EditResult | undefined;
+    /**
+     * Read `file`, an XER or MS Project XML file such as last month's, and make it the baseline: its tasks are matched to the open schedule's by ID.
+     * Resolves `{ ok: true, fileOnly }`, `fileOnly` the tasks only the file has, one line each in the file's order (`A1020 Pour slab`: the ID, a space, the name),
+     * the first 200 and then `and N more`; or a refusal that changes nothing: `"busy"`, or `"other"` with a sentence for a file that is empty, too big, not a
+     * schedule file, or holds no task with an ID the open schedule has. One undo step: Ctrl+Z puts back the baseline that was in force, or none.
+     */
+    setBaselineFromFile(file: File): Promise<CompareResult> | undefined;
+}
+/** Wrap `commands` so that each does nothing and returns undefined once `destroyed()` is true. Every method is wrapped, so a method added to `Commands` is too. */
+export declare function guardCommands(commands: Commands, destroyed: () => boolean): Commands;

package/dist-lib/types/document.d.ts

@@ -0,0 +1,59 @@
+/** `text` as a gzip file's bytes. */
+export declare function gzip(text: string): Promise<Uint8Array<ArrayBuffer>>;
+/**
+ * The document text `bytes` holds, or `null` when `bytes` is not a gzip file whose JSON says `"format":"gantt"` (or the older value) (a P6
+ * or MS Project file, or any other gzip). A gzip file that cannot be read rejects.
+ */
+export declare function documentText(bytes: Uint8Array): Promise<string | null>;
+/** Hand `bytes` to the browser as a download called `fileName`, of media type `type` (a gzip file unless said). Returns when the download has started. */
+export declare function download(fileName: string, bytes: Uint8Array<ArrayBuffer>, type?: string): void;
+/** The schedule's name for a file: its name without the extension, `untitled` when nothing is left. */
+export declare function documentName(fileName: string | undefined): string;
+/** What `Gantt.load` takes: a document (the JSON of `toDocument`) or a file. */
+export type LoadSource = {
+    document: unknown;
+} | {
+    file: File;
+};
+/** What `Gantt.load` resolves with. A bad source gives `ok: false` and a line for a person; the schedule is as it was. */
+export type LoadResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+/** What an export returns: the file's bytes and one line for each thing it cannot carry. */
+export interface ExportResult {
+    bytes: Uint8Array<ArrayBuffer>;
+    leftOut: string[];
+}
+/** The `{ bytes, left_out }` object of `App.export_xer` and `App.export_mspdi`, as an `ExportResult`. */
+export declare function toExportResult(raw: unknown): ExportResult;
+/**
+ * The schedule-quality counts `Gantt.checks` returns. Each is a count of tasks or links, and none says pass or fail. `invalidDates` is
+ * `null` when the schedule has no data date, because a 0 would read as a check that ran and found nothing.
+ */
+export interface ChecksReport {
+    /** Unfinished tasks with no predecessor or no successor; summary tasks are not counted. */
+    missingLogic: number;
+    /** Links with a negative lag. */
+    leads: number;
+    /** Links with a positive lag. */
+    lags: number;
+    /** All links. */
+    links: number;
+    /** Links of type finish to start. */
+    finishToStart: number;
+    /** Unfinished tasks with more than 44 working days of total float. */
+    highFloat: number;
+    /** Tasks longer than 44 working days. */
+    highDuration: number;
+    /** Tasks with an actual start or finish after the data date; `null` without a data date. */
+    invalidDates: number | null;
+    /** Tasks the baseline had finishing by the data date that finished later or have not finished; 0 with no baseline or no data date. */
+    missed: number;
+    /** Tasks finished over tasks the baseline had finishing by the data date, 0 to 1; `null` with no baseline, no data date, or none due. */
+    executionIndex: number | null;
+}
+/** The JSON text of `App.checks`, as a `ChecksReport`. */
+export declare function toChecksReport(json: string): ChecksReport;

package/dist-lib/types/edit-result.d.ts

@@ -0,0 +1,51 @@
+/** Why an edit command changed nothing. */
+export type EditRefusal = 
+/** A cell is being edited, or a bar or a link is being pressed or dragged (`Gantt.busy()`). */
+"busy"
+/** The schedule has no outline (a generated stress fixture). */
+ | "noOutline"
+/** `deleteRow` with no task selected, `deleteLink` with no link selected. */
+ | "noSelection"
+/** `insertRow` under a row filter or a lookahead window: the new row would not pass it and would vanish. */
+ | "filterActive"
+/** `deleteRow` on a summary: delete or move its sub-tasks first. */
+ | "hasChildren"
+/** `clearBaseline` or `addNewToBaseline` with no baseline set. */
+ | "noBaseline"
+/** `setDataDate` with text that is not a real day written `YYYY-MM-DD`. */
+ | "badDate"
+/** Anything else the schedule refused (rare: a solve that fails). */
+ | "other";
+/** Why nothing changed: `reason` to match on, `message` to show (the chart's own sentence for it). */
+export type Refusal = {
+    ok: false;
+    reason: EditRefusal;
+    message: string;
+};
+/** What `setDataDate`, `setBaseline`, `clearBaseline`, `addNewToBaseline` and, in a promise, `setBaselineFromFile` answer. */
+export type EditResult = {
+    ok: true;
+} | Refusal;
+/** What `setBaselineFromFile` answers in a promise: `fileOnly` names the tasks only the file has (`A1020 Pour slab`), the first 200 and then `and N more`; or why nothing changed. */
+export type CompareResult = {
+    ok: true;
+    fileOnly: readonly string[];
+} | Refusal;
+/** What `insertRow` and `deleteRow` answer: the task inserted or deleted, or why nothing changed. */
+export type RowResult = {
+    ok: true;
+    task: number;
+} | Refusal;
+/** What `deleteLink` answers: the link removed (a dependency slot), or why nothing changed. */
+export type LinkResult = {
+    ok: true;
+    link: number;
+} | Refusal;
+/** Read the JSON a `try_*` export answered. */
+export declare function readAnswer(json: string): {
+    ok: true;
+    task?: number;
+    link?: number;
+} | Refusal;
+/** A refusal the page makes before asking the app, worded by the app: `"busy"`, or `"badDate"` for a day that is not one. */
+export declare const refused: (reason: "busy" | "badDate") => Refusal;