@chelone/core 0.6.0 → 0.7.0

package/dist/controller/inspector.js

@@ -0,0 +1,64 @@
+import { createMicroStore } from "../store/micro-store.js";
+import { getDataTableColumnId } from "./data-table-columns.js";
+// src/controller/inspector.ts
+function createInspector() {
+	const store = createMicroStore({
+		enabled: false,
+		selected: null
+	});
+	const enable = () => store.setState({ enabled: true });
+	const disable = () => store.setState({
+		enabled: false,
+		selected: null
+	});
+	return {
+		store,
+		enable,
+		disable,
+		toggle() {
+			if (store.getSnapshot().enabled) disable();
+			else enable();
+		},
+		select(selection) {
+			if (!store.getSnapshot().enabled) return;
+			store.setState({ selected: selection });
+		},
+		release(key) {
+			if (store.getSnapshot().selected?.key !== key) return;
+			store.setState({ selected: null });
+		}
+	};
+}
+var inspectorPositionKey = "chelone.inspector.position";
+var clamp = (value, min, max) => Math.min(Math.max(value, min), Math.max(min, max));
+/**
+* Keeps the panel's drag handle on screen. A missing or non-finite position
+* gives the top right corner.
+*/
+function clampInspectorPosition(position, { viewportWidth, viewportHeight, panelWidth, margin = 8, handleHeight = 48 }) {
+	const maxX = viewportWidth - panelWidth - margin;
+	const maxY = viewportHeight - handleHeight;
+	if (!position || !Number.isFinite(position.x) || !Number.isFinite(position.y)) return {
+		x: clamp(maxX, margin, maxX),
+		y: margin
+	};
+	return {
+		x: clamp(position.x, margin, maxX),
+		y: clamp(position.y, margin, maxY)
+	};
+}
+function defaultConfigurableInputsStoreKey(resource) {
+	return `${resource}.inputs`;
+}
+function configurableInputColumns(inputs) {
+	return inputs.map(({ source, label }, index) => {
+		const column = { id: getDataTableColumnId({
+			source,
+			label
+		}) ?? `input-${index}` };
+		if (typeof source === "string") column.source = source;
+		if (typeof label === "string") column.label = label;
+		return column;
+	});
+}
+export { clampInspectorPosition, configurableInputColumns, createInspector, defaultConfigurableInputsStoreKey, inspectorPositionKey };

package/dist/controller/job-monitor.d.ts

@@ -8,12 +8,11 @@
  */
 import type { Identifier } from "../resource/identifier.js";
 import type { ResourceRecord } from "../resource/record.js";
-import type { SourceKey } from "../resource/source-path.js";
 /** The monitor's tabs, in order. One `buildKanbanBuckets` column per status. */
 export declare const DEFAULT_JOB_TABS: readonly ["running", "queued", "failed", "done"];
-export interface JobActionOptions<TRecord = Record<string, unknown>> {
+export interface JobActionOptions<TRecord extends object> {
     /** Record field holding the job status, a top-level key. Default `"status"`. */
-    statusSource?: SourceKey<TRecord>;
+    statusSource?: keyof TRecord & string;
     /** Statuses a job can be retried from. Default `["failed"]`. */
     retryFrom?: readonly string[];
     /** Statuses a job can be cancelled from. Default `["running", "queued"]`. */
@@ -35,7 +34,7 @@ export interface JobPlan<TRecord> {
     data: Record<string, string>;
     previousData: TRecord;
 }
-export declare function getJobActions<TRecord = Record<string, unknown>>(record: TRecord & object, options?: JobActionOptions<TRecord>): JobActions;
+export declare function getJobActions<TRecord extends object>(record: TRecord & object, options?: JobActionOptions<TRecord>): JobActions;
 /** The `update` that retries the job, or `null` when it cannot be retried. */
 export declare function planJobRetry<TRecord extends ResourceRecord = ResourceRecord>(record: TRecord, options?: JobActionOptions<TRecord>): JobPlan<TRecord> | null;
 /** The `update` that cancels the job, or `null` when it cannot be cancelled. */

package/dist/controller/job-monitor.js

@@ -1,59 +1,49 @@
 import { getAllowedTransitions } from "./record-workflow.js";
-const DEFAULT_JOB_TABS = [
-  "running",
-  "queued",
-  "failed",
-  "done"
+// src/controller/job-monitor.ts
+/** The monitor's tabs, in order. One `buildKanbanBuckets` column per status. */
+var DEFAULT_JOB_TABS = [
+	"running",
+	"queued",
+	"failed",
+	"done"
 ];
 function canMove(record, source, from, to) {
-  const transitions = Object.fromEntries(from.map((status) => [status, [to]]));
-  const { current, allowed } = getAllowedTransitions(record, {
-    source,
-    transitions
-  });
-  return { status: current, allowed: allowed.includes(to) };
+	const transitions = Object.fromEntries(from.map((status) => [status, [to]]));
+	const { current, allowed } = getAllowedTransitions(record, {
+		source,
+		transitions
+	});
+	return {
+		status: current,
+		allowed: allowed.includes(to)
+	};
 }
 function getJobActions(record, options = {}) {
-  const {
-    statusSource = "status",
-    retryFrom = ["failed"],
-    cancelFrom = ["running", "queued"],
-    retryValue = "queued",
-    cancelValue = "cancelled"
-  } = options;
-  const retry = canMove(record, statusSource, retryFrom, retryValue);
-  const cancel = canMove(record, statusSource, cancelFrom, cancelValue);
-  return {
-    status: retry.status,
-    canRetry: retry.allowed,
-    canCancel: cancel.allowed
-  };
+	const { statusSource = "status", retryFrom = ["failed"], cancelFrom = ["running", "queued"], retryValue = "queued", cancelValue = "cancelled" } = options;
+	const retry = canMove(record, statusSource, retryFrom, retryValue);
+	const cancel = canMove(record, statusSource, cancelFrom, cancelValue);
+	return {
+		status: retry.status,
+		canRetry: retry.allowed,
+		canCancel: cancel.allowed
+	};
 }
 function plan(record, source, value, allowed) {
-  if (!allowed) return null;
-  return { id: record.id, data: { [source]: value }, previousData: record };
+	if (!allowed) return null;
+	return {
+		id: record.id,
+		data: { [source]: value },
+		previousData: record
+	};
 }
+/** The `update` that retries the job, or `null` when it cannot be retried. */
 function planJobRetry(record, options = {}) {
-  const { statusSource = "status", retryValue = "queued" } = options;
-  return plan(
-    record,
-    statusSource,
-    retryValue,
-    getJobActions(record, options).canRetry
-  );
+	const { statusSource = "status", retryValue = "queued" } = options;
+	return plan(record, statusSource, retryValue, getJobActions(record, options).canRetry);
 }
+/** The `update` that cancels the job, or `null` when it cannot be cancelled. */
 function planJobCancel(record, options = {}) {
-  const { statusSource = "status", cancelValue = "cancelled" } = options;
-  return plan(
-    record,
-    statusSource,
-    cancelValue,
-    getJobActions(record, options).canCancel
-  );
+	const { statusSource = "status", cancelValue = "cancelled" } = options;
+	return plan(record, statusSource, cancelValue, getJobActions(record, options).canCancel);
 }
-export {
-  DEFAULT_JOB_TABS,
-  getJobActions,
-  planJobCancel,
-  planJobRetry
-};
+export { DEFAULT_JOB_TABS, getJobActions, planJobCancel, planJobRetry };

package/dist/controller/kanban-board.d.ts

@@ -9,7 +9,6 @@
  */
 import type { Identifier } from "../resource/identifier.js";
 import type { ResourceRecord } from "../resource/record.js";
-import type { SourceKey } from "../resource/source-path.js";
 export interface KanbanColumnDef {
     /** Value written to `groupSource` by a drop into this column. */
     id: string;
@@ -36,11 +35,11 @@ export interface KanbanMove<R> {
  * is in no bucket, and records keep list order inside a bucket. A repeated
  * column id keeps the first column's records and leaves the later one empty.
  */
-export declare function buildKanbanBuckets<R extends ResourceRecord>(records: readonly R[], groupSource: SourceKey<R>, columns: readonly KanbanColumnDef[]): KanbanBucket<R>[];
+export declare function buildKanbanBuckets<R extends ResourceRecord>(records: readonly R[], groupSource: keyof R & string, columns: readonly KanbanColumnDef[]): KanbanBucket<R>[];
 /**
  * The update a drop into `targetColumnId` asks for, or `null` when there is
  * nothing to write: the target is not a column, or the record already sits in
  * it. A drop that writes nothing still fires a data-provider `update` on every
  * board that re-renders on a dropped drag, so the adapters ask here first.
  */
-export declare function planKanbanMove<R extends ResourceRecord>(record: R, groupSource: SourceKey<R>, columns: readonly KanbanColumnDef[], targetColumnId: string): KanbanMove<R> | null;
+export declare function planKanbanMove<R extends ResourceRecord>(record: R, groupSource: keyof R & string, columns: readonly KanbanColumnDef[], targetColumnId: string): KanbanMove<R> | null;

package/dist/controller/kanban-board.js

@@ -1,30 +1,49 @@
+// src/controller/kanban-board.ts
+/**
+* The column key a record sits under: its group value as a string, with a
+* missing or null value reading as `""`. A top-level key, because a move can
+* only write `{ [source]: value }` — as in {@link getAllowedTransitions}.
+*/
 function bucketKey(record, groupSource) {
-  const value = record[groupSource];
-  return String(value ?? "");
+	return String(record[groupSource] ?? "");
 }
+/**
+* One bucket per column, in column order, empty columns included. A record
+* lands in the column whose id is its group key; a record that names no column
+* is in no bucket, and records keep list order inside a bucket. A repeated
+* column id keeps the first column's records and leaves the later one empty.
+*/
 function buildKanbanBuckets(records, groupSource, columns) {
-  const buckets = columns.map((column) => ({
-    column,
-    records: []
-  }));
-  const bucketOf = /* @__PURE__ */ new Map();
-  columns.forEach((column, index) => {
-    if (!bucketOf.has(column.id)) bucketOf.set(column.id, index);
-  });
-  for (const record of records) {
-    const index = bucketOf.get(bucketKey(record, groupSource));
-    if (index === void 0) continue;
-    buckets[index].records.push(record);
-  }
-  return buckets;
+	const buckets = columns.map((column) => ({
+		column,
+		records: []
+	}));
+	const bucketOf = /* @__PURE__ */ new Map();
+	columns.forEach((column, index) => {
+		if (!bucketOf.has(column.id)) bucketOf.set(column.id, index);
+	});
+	for (const record of records) {
+		const index = bucketOf.get(bucketKey(record, groupSource));
+		if (index === void 0) continue;
+		const bucket = buckets[index];
+		if (bucket) bucket.records.push(record);
+	}
+	return buckets;
 }
+/**
+* The update a drop into `targetColumnId` asks for, or `null` when there is
+* nothing to write: the target is not a column, or the record already sits in
+* it. A drop that writes nothing still fires a data-provider `update` on every
+* board that re-renders on a dropped drag, so the adapters ask here first.
+*/
 function planKanbanMove(record, groupSource, columns, targetColumnId) {
-  if (!columns.some((column) => column.id === targetColumnId)) return null;
-  if (bucketKey(record, groupSource) === targetColumnId) return null;
-  const data = { [groupSource]: targetColumnId };
-  return { id: record.id, data, previousData: record };
+	if (!columns.some((column) => column.id === targetColumnId)) return null;
+	if (bucketKey(record, groupSource) === targetColumnId) return null;
+	const data = { [groupSource]: targetColumnId };
+	return {
+		id: record.id,
+		data,
+		previousData: record
+	};
 }
-export {
-  buildKanbanBuckets,
-  planKanbanMove
-};
+export { buildKanbanBuckets, planKanbanMove };

package/dist/controller/list-controller.d.ts

@@ -19,7 +19,7 @@ export interface ListControllerState<TRecord> {
     pageInfo: PageInfo | undefined;
     isPending: boolean;
     isFetching: boolean;
-    error: unknown;
+    error: Error | null;
     hasNextPage: boolean | undefined;
     hasPreviousPage: boolean | undefined;
 }
@@ -108,17 +108,17 @@ export declare function runSelectAll(notifications: NotificationStore | undefine
  * again after a success can say so.
  */
 export declare function createErrorAnnouncer(notifications: NotificationStore | undefined): {
-    announce(error: unknown): void;
+    announce(error: Error | null): void;
     rearm(): void;
 };
 /** `hasNextPage`/`hasPreviousPage` from the provider's `pageInfo` or, failing that, the total. */
-export declare function pageFlags(page: number, perPage: number, total: number | undefined, pageInfo: PageInfo | undefined): Pick<ListControllerState<unknown>, "hasNextPage" | "hasPreviousPage">;
+export declare function pageFlags(page: number, perPage: number, total: number | undefined, pageInfo: PageInfo | undefined): Pick<ListControllerState<ResourceRecord>, "hasNextPage" | "hasPreviousPage">;
 /**
  * The page an out-of-range state should move to, or undefined when it is in
  * range. Only a SETTLED result may move past page 1, so a reset-induced
  * refetch can never trigger another reset.
  */
-export declare function resetPageTarget(s: Pick<ListControllerState<unknown>, "page" | "perPage" | "total" | "data" | "isPending" | "isFetching">): number | undefined;
+export declare function resetPageTarget(s: Pick<ListControllerState<ResourceRecord>, "page" | "perPage" | "total" | "data" | "isPending" | "isFetching">): number | undefined;
 /**
  * Vanilla list controller: one QueryObserver mapped into a micro-store.
  *
@@ -142,7 +142,7 @@ export declare function resetPageTarget(s: Pick<ListControllerState<unknown>, "p
  * The actions of a list controller, for an adapter to spread next to its own
  * reactive state. They are the same functions across state changes.
  */
-export declare function listControllerActions(controller: Omit<ListController<unknown>, keyof MicroStore<ListControllerState<unknown>> | "defaultPerPage">): {
+export declare function listControllerActions(controller: Omit<ListController<ResourceRecord>, keyof MicroStore<ListControllerState<ResourceRecord>> | "defaultPerPage">): {
     setPage: (page: number) => void;
     setPerPage: (perPage: number) => void;
     setSort: (sort: SortPayload | SortPayload[]) => void;