@burdenoff/microfe-bigconsole 2026.1011.10 → 2026.1012.1

package/dist/bigconsole/utils/dataSinkList.d.ts

@@ -1,15 +0,0 @@
-import { DataSink, DataSinkSetupState, DataSinkStatus } from '../types';
-import { ListSortValue } from './listSort';
-
-export interface DataSinkRow {
-    dataSink: DataSink;
-    setupState: DataSinkSetupState;
-}
-export interface DataSinkListQuery {
-    setupState: 'all' | 'in_progress' | 'completed';
-    status: DataSinkStatus | null;
-    active: boolean | null;
-    search: string;
-    sort: ListSortValue;
-}
-export declare function selectDataSinks<T extends DataSinkRow>(rows: readonly T[], query: DataSinkListQuery): T[];

package/dist/bigconsole/utils/dataSinkList.js

@@ -1,15 +0,0 @@
-import { sortList as e } from "./listSort.js";
-//#region src/bigconsole/utils/dataSinkList.ts
-function t(t, n) {
-	let r = [...t];
-	if (n.setupState === "in_progress" ? r = r.filter((e) => e.setupState !== "completed") : n.setupState === "completed" && (r = r.filter((e) => e.setupState === "completed")), n.status !== null && (r = r.filter((e) => e.dataSink.status === n.status)), n.active !== null && (r = r.filter((e) => e.dataSink.isActive === n.active)), n.search.trim()) {
-		let e = n.search.toLowerCase();
-		r = r.filter((t) => t.dataSink.name?.toLowerCase().includes(e) || t.dataSink.key.toLowerCase().includes(e) || t.dataSink.description?.toLowerCase().includes(e));
-	}
-	return e(r, n.sort, {
-		name: (e) => e.dataSink.name || e.dataSink.key,
-		updatedAt: (e) => e.dataSink.updatedAt
-	});
-}
-//#endregion
-export { t as selectDataSinks };

package/dist/bigconsole/utils/formDirty.d.ts

@@ -1,82 +0,0 @@
-/**
- * Form dirty helpers (BOFF-8060, N3 leave guard).
- *
- * Pure functions, no React, so the "is this editor holding an unsaved draft"
- * decision is testable without a DOM. Each editor keeps a baseline of the
- * values it seeded or last saved, and reports `isDirty(current, baseline)` to
- * `useUnsavedChanges`.
- *
- * Two rules keep the signal honest:
- * - A missing baseline (`null`/`undefined`) is CLEAN. An editor whose seed has
- *   not landed yet has nothing to lose, and reporting dirty there would make a
- *   freshly opened page refuse the assistant's navigation.
- * - Comparison is by value (stable JSON, sorted keys, `undefined` dropped), so
- *   object identity, key order and a refetch that returns equal data never
- *   count as an edit.
- */
-/** JSON with object keys sorted at every depth, so key order never matters. */
-export declare function stableStringify(value: unknown): string;
-/**
- * True when `current` differs by value from `baseline`. A missing baseline is
- * clean (see the module note).
- */
-export declare function isDirty(current: unknown, baseline: unknown): boolean;
-/**
- * Whether an edit form should be (re)seeded from the record the store now holds.
- *
- * A record can arrive twice: first as a partial list item (no expression, ttl, version), then as
- * the full record after the detail fetch. The second arrival must refresh a form the person has
- * not touched, otherwise the partial values would be saved over the stored ones. It must never
- * overwrite an edit in progress.
- *  - `seededId`: the id of the record the form was last seeded from (null = never seeded);
- *  - `form` / `baseline`: the current form and the form as last seeded or saved.
- * Seed when the record is a different one, or when the form still equals its baseline (a missing
- * baseline counts as clean). Skip only when the same record is loaded and the form is dirty.
- */
-export declare function shouldReseedForm(seededId: string | null, recordId: string, form: unknown, baseline: unknown): boolean;
-/** A grid item: react-grid-layout names the id `i`, our own widgets use `id`. */
-export type LayoutItem = {
-    readonly id: string;
-    readonly x: number;
-    readonly y: number;
-    readonly w: number;
-    readonly h: number;
-} | {
-    readonly i: string;
-    readonly x: number;
-    readonly y: number;
-    readonly w: number;
-    readonly h: number;
-};
-/** Item id to `x,y,w,h`, keys in sorted order. */
-export type NormalisedLayout = Readonly<Record<string, string>>;
-/**
- * Reduces a layout to the four numbers per item that a person can change by
- * dragging or resizing. Array order, extra grid bookkeeping fields (`moved`,
- * `static`, min/max) and item order never matter.
- */
-export declare function normaliseLayout(items: readonly LayoutItem[]): NormalisedLayout;
-type LayoutInput = readonly LayoutItem[] | NormalisedLayout;
-/** True when the layout differs by value from the baseline. No baseline is clean. */
-export declare function layoutDirty(current: LayoutInput, baseline: LayoutInput | null | undefined): boolean;
-/**
- * react-grid-layout fires `onLayoutChange` on mount and again whenever it
- * compacts, with no person involved, so "a change event happened" is not a
- * dirty signal. The baseline therefore FLOATS (follows every layout change)
- * until the first user gesture (drag or resize stop), then FREEZES; from then on
- * `layoutDirty(current, tracker.baseline)` is the answer. Reloading the
- * dashboard or a successful save starts a fresh tracker; a failed save keeps
- * the old one, so the draft stays dirty.
- */
-export interface LayoutTracker {
-    readonly baseline: NormalisedLayout | null;
-    readonly frozen: boolean;
-}
-export declare const EMPTY_LAYOUT_TRACKER: LayoutTracker;
-/** A fresh floating tracker, for after a load or a successful save. */
-export declare function resetLayoutTracker(items: readonly LayoutItem[]): LayoutTracker;
-/** A layout-change event: moves the baseline while floating, ignored once frozen. */
-export declare function trackLayoutChange(tracker: LayoutTracker, items: readonly LayoutItem[]): LayoutTracker;
-/** The first user gesture: stops the baseline following layout changes. */
-export declare function freezeLayoutTracker(tracker: LayoutTracker): LayoutTracker;
-export {};

package/dist/bigconsole/utils/formDirty.js

@@ -1,21 +0,0 @@
-//#region src/bigconsole/utils/formDirty.ts
-function e(e) {
-	return JSON.stringify(t(e));
-}
-function t(e) {
-	if (Array.isArray(e)) return e.map(t);
-	if (typeof e == "object" && e) {
-		let n = e, r = {};
-		for (let e of Object.keys(n).sort()) r[e] = t(n[e]);
-		return r;
-	}
-	return e;
-}
-function n(t, n) {
-	return n == null ? !1 : e(t) !== e(n);
-}
-function r(e, t, r, i) {
-	return e === t ? !n(r, i) : !0;
-}
-//#endregion
-export { n as isDirty, r as shouldReseedForm };

package/dist/bigconsole/utils/insightsDraft.d.ts

@@ -1,29 +0,0 @@
-/**
- * Does the Insights page hold a description the person has typed and not submitted?
- * (BOFF-8060, N3/N4 leave guard.)
- *
- * The page has two draft textareas: the "Describe your dashboard" prompt and the refine
- * modal's "What should change?". Both are cleared by the page itself when their
- * submission is accepted (and when the refine modal is reopened), so the last submitted
- * value is always the empty string and "unsubmitted" reads as "non-empty". Pure
- * functions, no React, so the rule is testable without a DOM.
- *
- * - Whitespace-only text is clean: the page will not submit it, and nothing is lost.
- * - Text being submitted right now is clean: it already left the page (the mutation
- *   keeps running after the person navigates). If the submission fails the page keeps
- *   the text and clears the in-flight flag, so the draft reads dirty again.
- * - The refine text only counts while the refine modal is open.
- */
-export interface InsightsDraftState {
-    /** The "Describe your dashboard" textarea. */
-    readonly promptText: string;
-    /** A generation request for `promptText` is in flight. */
-    readonly isGenerating: boolean;
-    /** The refine modal is open. */
-    readonly refineOpen: boolean;
-    /** The refine modal's "What should change?" textarea. */
-    readonly refineText: string;
-    /** A refine request for the open generation is in flight. */
-    readonly refineBusy: boolean;
-}
-export declare function isInsightsDraftDirty(state: InsightsDraftState): boolean;

package/dist/bigconsole/utils/insightsDraft.js

@@ -1,8 +0,0 @@
-//#region src/bigconsole/utils/insightsDraft.ts
-var e = (e) => e.trim() !== "";
-function t(t) {
-	let n = e(t.promptText) && !t.isGenerating, r = t.refineOpen && e(t.refineText) && !t.refineBusy;
-	return n || r;
-}
-//#endregion
-export { t as isInsightsDraftDirty };

package/dist/bigconsole/utils/layoutBaseline.d.ts

@@ -1,130 +0,0 @@
-/**
- * Dashboard layout baseline (BOFF-8060, N3/N4: the dashboard leave guard).
- *
- * The dashboard builder keeps moved and resized widgets only in the widget store
- * until the toolbar Save runs (`DashboardBuilderPage.handleSave`, step 2). To tell
- * the assistant "this editor holds unsaved work" the builder needs one honest
- * boolean, and the store has none: `widgetStore.dirtyWidgetIds` is never marked and
- * `dashboardStore.hasUnsavedChanges` is never cleared. This module is that boolean,
- * as plain functions with no React, so it can be tested without a DOM.
- *
- * ★★ "A layout event happened" is NOT a dirty signal. Positions reach the store on
- * load (`setWidgets`), when a widget is created or deleted, and when a save writes
- * its own positions back, none of which is the person's work. Only a PERSON'S
- * placement is. So the baseline FLOATS (it is re-taken on every observation)
- * until the first placement by a person, and from then on it is FROZEN: it holds
- * the last layout the server is known to have, and "dirty" means the current
- * layout differs from it BY VALUE:
- *
- *   load / refetch / add / delete / save write-back  -> baseline follows, clean
- *   first drag, resize, or typed placement           -> baseline freezes
- *   a drag that moves and moves back                 -> equal again, clean
- *   a successful save                                -> baseline = what was saved
- *   a failed save                                    -> nothing happens, still dirty
- *
- * ★★ The "placement by a person" signal is `layoutEditRevision` on the widget
- * store, a counter bumped by `updateWidgetPosition` and by nothing else. It is the
- * ONE writer shared by the canvas (drag stop, resize stop) and the inspector's
- * "Position & size" fields, so a placement typed into the inspector, which never
- * touches the grid, freezes the baseline too. A signal taken from the grid alone
- * would let a floating baseline silently absorb it.
- *
- * Every function here is pure. `useDashboardLayoutBaseline` is the React shell.
- */
-/** One widget's grid cell, in grid units (columns / rows). */
-export interface LayoutRect {
-    readonly x: number;
-    readonly y: number;
-    readonly w: number;
-    readonly h: number;
-}
-export interface LayoutItem extends LayoutRect {
-    readonly id: string;
-}
-/**
- * Widget id -> cell, keys in sorted order. A `Map` (not a plain object) so an
- * id such as `"1"` or `"__proto__"` is only ever a key.
- */
-export type NormalisedLayout = ReadonlyMap<string, LayoutRect>;
-interface PositionLike {
-    readonly x?: number | null;
-    readonly y?: number | null;
-    readonly width?: number | null;
-    readonly height?: number | null;
-}
-/**
- * What a widget must carry for its cell to be read. Structural, so the store's
- * `Widget` satisfies it and a test can pass a plain object.
- */
-export interface LayoutSourceWidget {
-    readonly id: string;
-    readonly position?: PositionLike | null;
-    readonly positionX?: number | null;
-    readonly positionY?: number | null;
-    readonly positionWidth?: number | null;
-    readonly positionHeight?: number | null;
-}
-/**
- * The cell a widget with no stored size falls back to. These mirror
- * `DashboardGrid.widgetToLayout` exactly, so the baseline reads a widget the same
- * way the grid draws it.
- */
-export declare const DEFAULT_LAYOUT_CELL: LayoutRect;
-/**
- * Items -> a sorted `id -> x,y,w,h` map. Order of the input does not matter, a
- * repeated id keeps the last one, and a non-finite number becomes 0 so a stray
- * `NaN` (which is never equal to itself) cannot make a layout permanently dirty.
- */
-export declare function normaliseLayout(items: Iterable<LayoutItem>): NormalisedLayout;
-/** The widget store's widgets -> a normalised layout (every widget in the store, which is what Save sends). */
-export declare function layoutFromWidgets(widgets: Iterable<LayoutSourceWidget>): NormalisedLayout;
-/** The `{ id, position }` list `batchUpdatePositions` sends -> layout items (exactly what reached the server). */
-export declare function layoutItemsFromPositionUpdates(updates: ReadonlyArray<{
-    readonly id: string;
-    readonly position: PositionLike;
-}>): LayoutItem[];
-/** Same widgets in the same cells (by value; key order and object identity are irrelevant). */
-export declare function layoutEquals(a: NormalisedLayout, b: NormalisedLayout): boolean;
-/**
- * Does `current` differ from `baseline`? Different cells, a widget present on only
- * one side, or both, all count. With no baseline there is nothing to differ from,
- * so the answer is no: this never claims unsaved work it cannot point to.
- */
-export declare function layoutDirty(current: NormalisedLayout, baseline: NormalisedLayout | null): boolean;
-export interface LayoutBaselineState {
-    /** The layout the server is known to hold, or the last loaded one while floating. `null` until first observed. */
-    readonly baseline: NormalisedLayout | null;
-    /** True once a person has placed something since the baseline was taken. Frozen baselines do not follow the store. */
-    readonly frozen: boolean;
-    /** The last `layoutEditRevision` seen, to notice the next placement. `null` until first observed. */
-    readonly seenRevision: number | null;
-}
-export declare const INITIAL_LAYOUT_BASELINE: LayoutBaselineState;
-export type LayoutBaselineAction = 
-/** The store changed (or the page mounted): here is the layout and the placement counter now. */
-{
-    readonly type: 'observe';
-    readonly layout: NormalisedLayout;
-    readonly editRevision: number;
-}
-/**
- * The positions reached the server. `layout` is exactly what was sent;
- * `editRevision` is the counter read BEFORE the request started, so a
- * placement made while it was in flight is not mistaken for saved.
- */
- | {
-    readonly type: 'saved';
-    readonly layout: NormalisedLayout;
-    readonly editRevision: number;
-}
-/** A different dashboard: forget everything. */
- | {
-    readonly type: 'reset';
-};
-export declare function reduceLayoutBaseline(state: LayoutBaselineState, action: LayoutBaselineAction): LayoutBaselineState;
-/**
- * The one boolean the builder reports. A floating baseline is never dirty by
- * definition: it follows the store, so whatever differs is not the person's work.
- */
-export declare function isLayoutBaselineDirty(state: LayoutBaselineState, current: NormalisedLayout): boolean;
-export {};

package/dist/bigconsole/utils/layoutBaseline.js

@@ -1,96 +0,0 @@
-//#region src/bigconsole/utils/layoutBaseline.ts
-var e = {
-	x: 0,
-	y: 0,
-	w: 4,
-	h: 4
-}, t = (e) => typeof e == "number" && Number.isFinite(e) ? e : void 0, n = (e) => Number.isFinite(e) ? e : 0;
-function r(e, n, r) {
-	return t(e) ?? t(n) ?? r;
-}
-var i = (e, t) => e < t ? -1 : +(e > t);
-function a(e) {
-	let t = /* @__PURE__ */ new Map();
-	for (let r of e) t.set(r.id, {
-		x: n(r.x),
-		y: n(r.y),
-		w: n(r.w),
-		h: n(r.h)
-	});
-	return new Map([...t.entries()].sort(([e], [t]) => i(e, t)));
-}
-function o(t) {
-	let n = [];
-	for (let i of t) n.push({
-		id: i.id,
-		x: r(i.position?.x, i.positionX, e.x),
-		y: r(i.position?.y, i.positionY, e.y),
-		w: r(i.position?.width, i.positionWidth, e.w),
-		h: r(i.position?.height, i.positionHeight, e.h)
-	});
-	return a(n);
-}
-function s(t) {
-	return t.map((t) => ({
-		id: t.id,
-		x: r(t.position.x, void 0, e.x),
-		y: r(t.position.y, void 0, e.y),
-		w: r(t.position.width, void 0, e.w),
-		h: r(t.position.height, void 0, e.h)
-	}));
-}
-function c(e, t) {
-	if (e.size !== t.size) return !1;
-	for (let [n, r] of e) {
-		let e = t.get(n);
-		if (!e || r.x !== e.x || r.y !== e.y || r.w !== e.w || r.h !== e.h) return !1;
-	}
-	return !0;
-}
-function l(e, t) {
-	return t !== null && !c(e, t);
-}
-var u = {
-	baseline: null,
-	frozen: !1,
-	seenRevision: null
-};
-function d(e, t) {
-	switch (t.type) {
-		case "reset": return u;
-		case "observe": {
-			if (e.baseline === null) return {
-				baseline: t.layout,
-				frozen: !1,
-				seenRevision: t.editRevision
-			};
-			let n = t.editRevision !== e.seenRevision;
-			return e.frozen ? n ? {
-				...e,
-				seenRevision: t.editRevision
-			} : e : n ? {
-				baseline: e.baseline,
-				frozen: !0,
-				seenRevision: t.editRevision
-			} : c(t.layout, e.baseline) ? e : {
-				baseline: t.layout,
-				frozen: !1,
-				seenRevision: t.editRevision
-			};
-		}
-		case "saved": return e.baseline === null ? {
-			baseline: t.layout,
-			frozen: !1,
-			seenRevision: t.editRevision
-		} : {
-			baseline: t.layout,
-			frozen: e.seenRevision !== null && e.seenRevision > t.editRevision,
-			seenRevision: e.seenRevision
-		};
-	}
-}
-function f(e, t) {
-	return e.frozen && l(t, e.baseline);
-}
-//#endregion
-export { u as INITIAL_LAYOUT_BASELINE, f as isLayoutBaselineDirty, o as layoutFromWidgets, s as layoutItemsFromPositionUpdates, a as normaliseLayout, d as reduceLayoutBaseline };

package/dist/bigconsole/utils/listSort.d.ts

@@ -1,80 +0,0 @@
-/**
- * Shared "Sort by" model for BigConsole list pages (BOFF-8679).
- *
- * ★ One definition of the sort values, the comparator and the option labels, so
- * the visible `SortBySelect`, the page's own list pipeline and the assistant's
- * page-control adapter (`assistant/pageControls.ts`) cannot disagree: a person
- * who picks "Name Z–A" from the menu and a person who says "sort by name
- * descending" set the SAME state and get the SAME list.
- *
- * Pure: no React, no DOM, no i18n provider (labels come in through `Tr`).
- *
- * Only fields the list data really carries are offered:
- * - Name: every dashboard has `name`; a data sink may have a null `name`, in
- *   which case its `key` is what the card and the table show, so that is what
- *   sorts.
- * - Last updated: `updatedAt` on both. A row with no parseable date sorts last
- *   in both directions (it has no "age" to rank).
- */
-export type ListSortValue = 'default' | 'name-asc' | 'name-desc' | 'updated-desc' | 'updated-asc';
-export type ListSortField = 'name' | 'updated';
-export type SortTr = (key: string, fallback: string) => string;
-export interface ListSortOption {
-    value: ListSortValue;
-    label: string;
-}
-/** How a list item exposes the two sortable fields. */
-export interface ListSortKeys<T> {
-    /** The text the row shows as its name. */
-    name: (item: T) => string;
-    /** ISO timestamp of the last update, if any. */
-    updatedAt: (item: T) => string | null | undefined;
-}
-/** The i18n key and English source of every label used by the control. */
-export declare const LIST_SORT_COPY: {
-    readonly label: {
-        readonly key: "bigconsole.listSort.label";
-        readonly en: "Sort by";
-    };
-    readonly default: {
-        readonly key: "bigconsole.listSort.default";
-        readonly en: "Default order";
-    };
-    readonly nameAsc: {
-        readonly key: "bigconsole.listSort.nameAsc";
-        readonly en: "Name A–Z";
-    };
-    readonly nameDesc: {
-        readonly key: "bigconsole.listSort.nameDesc";
-        readonly en: "Name Z–A";
-    };
-    readonly updatedDesc: {
-        readonly key: "bigconsole.listSort.updatedDesc";
-        readonly en: "Last updated: newest";
-    };
-    readonly updatedAsc: {
-        readonly key: "bigconsole.listSort.updatedAsc";
-        readonly en: "Last updated: oldest";
-    };
-    readonly fieldName: {
-        readonly key: "bigconsole.listSort.field.name";
-        readonly en: "Name";
-    };
-    readonly fieldUpdated: {
-        readonly key: "bigconsole.listSort.field.updated";
-        readonly en: "Last updated";
-    };
-};
-/**
- * The list ordered by `value`. `default` returns the items in the order given
- * (the page's own default order, untouched). The sort is stable: rows that tie
- * keep their incoming order, so a re-sort never shuffles equal rows.
- */
-export declare function sortList<T>(items: readonly T[], value: ListSortValue, keys: ListSortKeys<T>): T[];
-/**
- * The options the visible control lists, in its words. `withDefault` adds the
- * "Default order" entry for a page whose natural order is not one of the four
- * (Dashboards: the server's order). A page whose default IS one of them
- * (Data Sinks: newest first) omits it and starts on that value.
- */
-export declare function listSortOptions(tr: SortTr, withDefault: boolean): ListSortOption[];

package/dist/bigconsole/utils/listSort.js

@@ -1,85 +0,0 @@
-//#region src/bigconsole/utils/listSort.ts
-var e = {
-	label: {
-		key: "bigconsole.listSort.label",
-		en: "Sort by"
-	},
-	default: {
-		key: "bigconsole.listSort.default",
-		en: "Default order"
-	},
-	nameAsc: {
-		key: "bigconsole.listSort.nameAsc",
-		en: "Name A–Z"
-	},
-	nameDesc: {
-		key: "bigconsole.listSort.nameDesc",
-		en: "Name Z–A"
-	},
-	updatedDesc: {
-		key: "bigconsole.listSort.updatedDesc",
-		en: "Last updated: newest"
-	},
-	updatedAsc: {
-		key: "bigconsole.listSort.updatedAsc",
-		en: "Last updated: oldest"
-	},
-	fieldName: {
-		key: "bigconsole.listSort.field.name",
-		en: "Name"
-	},
-	fieldUpdated: {
-		key: "bigconsole.listSort.field.updated",
-		en: "Last updated"
-	}
-}, t = new Intl.Collator(void 0, {
-	sensitivity: "base",
-	numeric: !0
-});
-function n(e) {
-	if (!e) return null;
-	let t = new Date(e).getTime();
-	return Number.isNaN(t) ? null : t;
-}
-function r(e, r, i) {
-	let a = [...e];
-	switch (r) {
-		case "default": return a;
-		case "name-asc": return a.sort((e, n) => t.compare(i.name(e), i.name(n)));
-		case "name-desc": return a.sort((e, n) => t.compare(i.name(n), i.name(e)));
-		case "updated-desc":
-		case "updated-asc": {
-			let e = r === "updated-desc" ? -1 : 1;
-			return a.sort((t, r) => {
-				let a = n(i.updatedAt(t)), o = n(i.updatedAt(r));
-				return a === null && o === null ? 0 : a === null ? 1 : o === null ? -1 : (a - o) * e;
-			});
-		}
-	}
-}
-function i(t, n) {
-	let r = [
-		{
-			value: "name-asc",
-			label: t(e.nameAsc.key, e.nameAsc.en)
-		},
-		{
-			value: "name-desc",
-			label: t(e.nameDesc.key, e.nameDesc.en)
-		},
-		{
-			value: "updated-desc",
-			label: t(e.updatedDesc.key, e.updatedDesc.en)
-		},
-		{
-			value: "updated-asc",
-			label: t(e.updatedAsc.key, e.updatedAsc.en)
-		}
-	];
-	return n ? [{
-		value: "default",
-		label: t(e.default.key, e.default.en)
-	}, ...r] : r;
-}
-//#endregion
-export { e as LIST_SORT_COPY, i as listSortOptions, r as sortList };

package/dist/bigconsole/utils/widgetFormDirty.d.ts

@@ -1,16 +0,0 @@
-/** True when `form` differs by value from `baseline`. Either side missing is clean. */
-export declare function isWidgetFormEdited<T>(form: T | null | undefined, baseline: T | null | undefined): boolean;
-/**
- * Adds an inferred DataSink binding to a form that is bound to `parserId` and has none.
- *
- * The widget inspector infers an absent `dataSinkId` from the parser's input sink key once the
- * parser resolves (AI-created widgets bind a parser without duplicating its input sink id). That
- * is the panel filling in what the widget already means, not an edit by the person. It is
- * applied to the form AND to the baseline with this one function, so the value compare of
- * `isWidgetFormEdited` reads clean. Returns the same object when nothing applies, so a state
- * updater using it does not trigger a re-render.
- */
-export declare function withInferredDataSink<T extends {
-    parserId?: string | null;
-    dataSinkId?: string | null;
-}>(form: T | null | undefined, parserId: string, dataSinkId: string): T | null;

package/dist/bigconsole/utils/widgetFormDirty.js

@@ -1,13 +0,0 @@
-import { isDirty as e } from "./formDirty.js";
-//#region src/bigconsole/utils/widgetFormDirty.ts
-function t(t, n) {
-	return t == null || n == null ? !1 : e(t, n);
-}
-function n(e, t, n) {
-	return e == null ? null : e.parserId !== t || e.dataSinkId ? e : {
-		...e,
-		dataSinkId: n
-	};
-}
-//#endregion
-export { t as isWidgetFormEdited, n as withInferredDataSink };