@svar-ui/kanban-store 2.6.0

package/dist/index.d.mts

@@ -0,0 +1,231 @@
+import { EventBus, Store, TDataConfig, TWritableCreator } from "@svar-ui/lib-state";
+
+//#region src/cards_store.d.ts
+declare class CardsStore {
+  private _cards;
+  constructor(initial?: KanbanCard[]);
+  getCards(): KanbanCard[];
+  getById(id: CardID): KanbanCard | undefined;
+  add(card: KanbanCard, after?: CardID): KanbanCard;
+  update(id: CardID, patch: Partial<KanbanCard>): KanbanCard | undefined;
+  upsert(card: KanbanCard): KanbanCard;
+  remove(id: CardID): boolean;
+  move(id: CardID, before?: CardID | null): boolean;
+  private _assertHasId;
+}
+//#endregion
+//#region src/types.d.ts
+type Brandmark = {
+  text: string;
+  link?: string;
+  style: string;
+};
+type CardID = string | number;
+type ColumnID = string | number;
+type ColumnDataStatus = "unknown" | "loading" | "loaded";
+type ColumnDataState = {
+  status: ColumnDataStatus;
+};
+type KanbanCard = {
+  id: CardID;
+  [key: string]: any;
+};
+type ColumnConfig = {
+  id: ColumnID;
+  label: string;
+  css?: string;
+  metadata?: Record<string, any>;
+  cardLimit?: number | boolean;
+  addCard?: boolean;
+  collapsed?: boolean;
+};
+type ColumnView = {
+  id: ColumnID;
+  label: string;
+  css?: string;
+  metadata?: Record<string, any>;
+  cardLimit?: number | boolean;
+  addCard: boolean;
+  collapsed: boolean;
+  overLimit: boolean;
+  dataStatus: ColumnDataStatus;
+  cards: KanbanCard[];
+};
+type KanbanModel$1 = {
+  columns: ColumnView[];
+};
+type ColumnAccessor = string | {
+  get: (card: KanbanCard) => ColumnID;
+  set: (card: KanbanCard, value: ColumnID) => KanbanCard;
+};
+type SortCriterion = ((a: KanbanCard, b: KanbanCard) => number) | {
+  field: string;
+  dir?: "asc" | "desc";
+} | null;
+type FilterPredicate = (card: KanbanCard) => boolean;
+type State = {
+  renderMode: string;
+  cards: CardsStore;
+  columns: ColumnConfig[];
+  columnAccessor: ColumnAccessor;
+  filters: Map<string, FilterPredicate>;
+  sort: SortCriterion;
+  editorData: KanbanCard | null;
+  dynamicData: boolean;
+  columnData: Map<ColumnID, ColumnDataState>;
+  history: HistoryState;
+  viewData: KanbanModel$1;
+};
+type IData = State;
+type StateInput = Partial<Omit<State, "cards" | "columns" | "filters"> & {
+  cards: KanbanCard[] | CardsStore;
+  columns: ColumnConfig[];
+  filters: Map<string, FilterPredicate>;
+}>;
+type KanbanStoreOptions = {
+  undo?: boolean;
+};
+type HistoryState = {
+  undo: number;
+  redo: number;
+};
+type HistoryActionName = "add-card" | "update-card" | "move-card" | "duplicate-card" | "delete-card";
+type ExportConfig = {
+  url?: string | ((data: ExportConfig, records: KanbanCard[], helpers: ExportHelpers) => void);
+  format?: string;
+  fileName?: string;
+  skin?: string;
+  paper?: {
+    fitSize?: boolean;
+    size?: string | {
+      width: number;
+      height: number;
+    };
+    landscape?: boolean;
+    styles?: string | string[];
+    margins?: {
+      top?: number;
+      bottom?: number;
+      left?: number;
+      right?: number;
+    };
+    header?: string;
+    footer?: string;
+    scale?: number;
+  };
+  excel?: {
+    sheetNames?: string[];
+    dateFormat?: string;
+    indent?: "native" | "spaces";
+  };
+  data?: Record<string, any>;
+};
+type ExportHelpers = {
+  post: (url: string, data: Record<string, string>) => void;
+  serialize: (value: any) => string;
+};
+interface IKanbanStore {
+  getState(): State;
+  setState(state: StateInput, ctx?: any): any;
+  pushUndo<A extends HistoryActionName>(action: A, ev: StoreActions[A]): void;
+  undo(): void;
+  redo(): void;
+  resetHistory(): void;
+}
+interface StoreActions {
+  ["add-card"]: {
+    card: Partial<KanbanCard>;
+    edit?: boolean;
+    id?: CardID;
+    after?: CardID;
+  };
+  ["update-card"]: {
+    id: CardID;
+    card: Partial<KanbanCard>;
+  };
+  ["move-card"]: {
+    id: CardID;
+    column?: ColumnID;
+    before?: CardID | null;
+  };
+  ["update-column"]: {
+    id: ColumnID;
+    column: Partial<ColumnConfig>;
+  };
+  ["duplicate-card"]: {
+    id: CardID;
+    card?: Partial<KanbanCard>;
+    edit?: boolean;
+  };
+  ["delete-card"]: {
+    id: CardID;
+  };
+  ["select-card"]: {
+    id: CardID | null;
+  };
+  ["filter-cards"]: {
+    filter?: FilterPredicate | null;
+    tag?: string;
+  };
+  ["sort-cards"]: {
+    sort?: SortCriterion;
+  };
+  ["request-data"]: {
+    id: ColumnID;
+  };
+  ["provide-data"]: {
+    id?: ColumnID;
+    cards: KanbanCard[];
+  };
+  ["export-data"]: ExportConfig;
+  ["undo"]: Record<string, never>;
+  ["redo"]: Record<string, never>;
+}
+//#endregion
+//#region src/kanban_store.d.ts
+declare class KanbanStore extends Store<IData> {
+  in: EventBus<StoreActions, keyof StoreActions>;
+  meta: Record<string, any>;
+  private _router;
+  constructor(w: TWritableCreator, options?: KanbanStoreOptions);
+  init(state: StateInput): void;
+  getCards(): KanbanCard[];
+  pushUndo<A extends HistoryActionName>(action: A, ev: StoreActions[A]): void;
+  undo(): void;
+  redo(): void;
+  resetHistory(): void;
+  getBrandmark(): Brandmark | null;
+  setState(state: Partial<IData>, ctx?: TDataConfig): {
+    [key: string]: (() => void) | null;
+  };
+}
+//#endregion
+//#region src/model.d.ts
+declare class KanbanModel implements KanbanModel$1 {
+  columns: ColumnView[];
+  constructor(data?: Partial<KanbanModel$1>);
+}
+//#endregion
+//#region src/locale/index.d.ts
+declare function locale(initialData: any): {
+  data: any;
+  _(key: string): any;
+  __(group: string, key: string): any;
+  getGroup(group: string): (key: string) => any;
+  extend(values: any): /*elided*/any;
+};
+//#endregion
+//#region src/constants.d.ts
+declare function getMenuOptions(): {
+  id: string;
+  text: string;
+  icon: string;
+}[];
+type ToolbarButtonConfig = {
+  add?: boolean;
+  undo?: boolean;
+  sort?: boolean;
+};
+declare function getToolbarItems(config?: ToolbarButtonConfig): any[];
+//#endregion
+export { Brandmark, CardID, CardsStore, ColumnAccessor, ColumnConfig, ColumnDataState, ColumnDataStatus, ColumnID, ColumnView, ExportConfig, ExportHelpers, FilterPredicate, HistoryActionName, HistoryState, IData, IKanbanStore, KanbanCard, KanbanModel, KanbanStore, KanbanStoreOptions, SortCriterion, State, StateInput, StoreActions, type ToolbarButtonConfig, getMenuOptions, getToolbarItems, locale };

package/dist/index.mjs

@@ -0,0 +1,512 @@
+import { DataRouter, EventBus, Store, tempID } from "@svar-ui/lib-state";
+
+//#region src/cards_store.ts
+var CardsStore = class {
+	_cards;
+	constructor(initial = []) {
+		this._cards = initial.slice();
+		this._cards.forEach((card) => this._assertHasId(card));
+	}
+	getCards() {
+		return this._cards;
+	}
+	getById(id) {
+		return this._cards.find((card) => card.id === id);
+	}
+	add(card, after) {
+		this._assertHasId(card);
+		const next = { ...card };
+		const index = after === void 0 ? -1 : this._cards.findIndex((item) => item.id === after);
+		if (index === -1) this._cards.push(next);
+		else this._cards.splice(index + 1, 0, next);
+		return next;
+	}
+	update(id, patch) {
+		const index = this._cards.findIndex((card) => card.id === id);
+		if (index === -1) return;
+		const next = {
+			...this._cards[index],
+			...patch
+		};
+		this._assertHasId(next);
+		this._cards[index] = next;
+		return next;
+	}
+	upsert(card) {
+		this._assertHasId(card);
+		const next = { ...card };
+		const index = this._cards.findIndex((item) => item.id === card.id);
+		if (index === -1) this._cards.push(next);
+		else this._cards[index] = next;
+		return next;
+	}
+	remove(id) {
+		const index = this._cards.findIndex((card) => card.id === id);
+		if (index === -1) return false;
+		this._cards.splice(index, 1);
+		return true;
+	}
+	move(id, before) {
+		const from = this._cards.findIndex((card) => card.id === id);
+		if (from === -1) return false;
+		if (before === id) return true;
+		let to = this._cards.length;
+		if (before != null) {
+			to = this._cards.findIndex((card) => card.id === before);
+			if (to === -1) return false;
+		}
+		const [card] = this._cards.splice(from, 1);
+		if (from < to) to -= 1;
+		this._cards.splice(to, 0, card);
+		return true;
+	}
+	_assertHasId(card) {
+		if (card.id == null) throw new Error("Kanban cards must have an id");
+	}
+};
+
+//#endregion
+//#region src/model.ts
+var KanbanModel = class {
+	columns;
+	constructor(data = {}) {
+		this.columns = data.columns || [];
+	}
+};
+
+//#endregion
+//#region src/actions/add-card.ts
+function add_card_default(store, ev) {
+	const { cards, columns, columnAccessor } = store.getState();
+	let card = {
+		...ev.card,
+		id: ev.id ?? ev.card.id ?? tempID()
+	};
+	const columnId = readColumn$1(card, columnAccessor);
+	if (!columns.some((column) => column.id === columnId) && columns.length) card = writeColumn$2(card, columnAccessor, columns[0].id);
+	const added = cards.add(card, ev.after);
+	ev.id = added.id;
+	store.setState({
+		cards,
+		...ev.edit ? { editorData: { ...added } } : {}
+	});
+}
+function readColumn$1(card, accessor) {
+	return typeof accessor === "string" ? card[accessor] : accessor.get(card);
+}
+function writeColumn$2(card, accessor, column) {
+	return typeof accessor === "string" ? {
+		...card,
+		[accessor]: column
+	} : accessor.set(card, column);
+}
+
+//#endregion
+//#region src/actions/update-card.ts
+function update_card_default(store, ev) {
+	const { cards } = store.getState();
+	if (cards.update(ev.id, ev.card)) store.setState({ cards });
+}
+
+//#endregion
+//#region src/actions/move-card.ts
+function move_card_default(store, ev) {
+	const { cards, columns, columnAccessor } = store.getState();
+	const card = cards.getById(ev.id);
+	if (!card) return;
+	const currentColumn = readColumn(card, columnAccessor);
+	const targetColumn = ev.column ?? currentColumn;
+	if (ev.column !== void 0 && !columns.some((column) => column.id === targetColumn)) return;
+	if (ev.before != null) {
+		const beforeCard = cards.getById(ev.before);
+		const beforeColumn = ev.before === ev.id ? targetColumn : beforeCard && readColumn(beforeCard, columnAccessor);
+		if (!beforeCard || beforeColumn !== targetColumn) return;
+	}
+	if (targetColumn !== currentColumn) {
+		const nextCard = writeColumn$1(card, columnAccessor, targetColumn);
+		cards.update(ev.id, nextCard);
+	}
+	if (cards.move(ev.id, ev.before)) store.setState({ cards });
+}
+function readColumn(card, accessor) {
+	return typeof accessor === "string" ? card[accessor] : accessor.get(card);
+}
+function writeColumn$1(card, accessor, column) {
+	return typeof accessor === "string" ? { [accessor]: column } : accessor.set(card, column);
+}
+
+//#endregion
+//#region src/actions/duplicate-card.ts
+function duplicate_card_default(store, ev) {
+	const { cards } = store.getState();
+	const source = cards.getById(ev.id);
+	if (!source) return;
+	const duplicate = {
+		...source,
+		...ev.card,
+		id: tempID()
+	};
+	const added = cards.add(duplicate, ev.id);
+	store.setState({
+		cards,
+		...ev.edit ? { editorData: { ...added } } : {}
+	});
+}
+
+//#endregion
+//#region src/actions/delete-card.ts
+function delete_card_default(store, ev) {
+	const { cards, editorData } = store.getState();
+	if (!cards.remove(ev.id)) return;
+	store.setState({
+		cards,
+		...editorData?.id === ev.id ? { editorData: null } : {}
+	});
+}
+
+//#endregion
+//#region src/actions/select-card.ts
+function select_card_default(store, ev) {
+	if (ev.id === null) {
+		store.setState({ editorData: null });
+		return;
+	}
+	const card = store.getState().cards.getById(ev.id);
+	if (card) store.setState({ editorData: { ...card } });
+}
+
+//#endregion
+//#region src/actions/update-column.ts
+function update_column_default(store, ev) {
+	const { columns } = store.getState();
+	const index = columns.findIndex((column) => column.id === ev.id);
+	if (index === -1) return;
+	columns[index] = {
+		...columns[index],
+		...ev.column
+	};
+	store.setState({ columns });
+}
+
+//#endregion
+//#region src/actions/filter-cards.ts
+function filter_cards_default(store, ev = {}) {
+	const { filters } = store.getState();
+	const hasFilter = Object.prototype.hasOwnProperty.call(ev, "filter");
+	const hasTag = Object.prototype.hasOwnProperty.call(ev, "tag");
+	const tag = ev.tag ?? "_default";
+	if (!hasFilter) if (hasTag) filters.delete(tag);
+	else filters.clear();
+	else if (ev.filter == null) if (hasTag) filters.delete(tag);
+	else filters.clear();
+	else filters.set(tag, ev.filter);
+	store.setState({ filters });
+}
+
+//#endregion
+//#region src/actions/sort-cards.ts
+function sort_cards_default(store, ev = {}) {
+	if (!Object.prototype.hasOwnProperty.call(ev, "sort") || ev.sort === void 0) return;
+	store.setState({ sort: ev.sort });
+}
+
+//#endregion
+//#region src/actions/provide-data.ts
+function provide_data_default(store, ev) {
+	const { cards, columns, columnAccessor, columnData } = store.getState();
+	if (ev.id) {
+		if (!columns.some((column) => column.id === ev.id)) return;
+		ev.cards.forEach((card) => {
+			cards.upsert(writeColumn(card, columnAccessor, ev.id));
+		});
+		const next = new Map(columnData);
+		next.set(ev.id, { status: "loaded" });
+		store.setState({
+			cards,
+			columnData: next
+		});
+	} else {
+		ev.cards.forEach((card) => {
+			cards.upsert(card);
+		});
+		store.setState({ cards });
+	}
+}
+function writeColumn(card, accessor, column) {
+	return typeof accessor === "string" ? {
+		...card,
+		[accessor]: column
+	} : accessor.set(card, column);
+}
+
+//#endregion
+//#region src/actions/index.ts
+function init(inBus, store) {
+	inBus.on("add-card", (params) => add_card_default(store, params));
+	inBus.on("update-card", (params) => update_card_default(store, params));
+	inBus.on("move-card", (params) => move_card_default(store, params));
+	inBus.on("duplicate-card", (params) => duplicate_card_default(store, params));
+	inBus.on("delete-card", (params) => delete_card_default(store, params));
+	inBus.on("select-card", (params) => select_card_default(store, params));
+	inBus.on("update-column", (params) => update_column_default(store, params));
+	inBus.on("filter-cards", (params) => filter_cards_default(store, params));
+	inBus.on("sort-cards", (params) => sort_cards_default(store, params));
+	inBus.on("provide-data", (params) => provide_data_default(store, params));
+}
+
+//#endregion
+//#region src/kanban_reactive.ts
+function reactive(store) {
+	return [{
+		in: [
+			"cards",
+			"columns",
+			"columnAccessor",
+			"filters",
+			"sort",
+			"dynamicData",
+			"columnData"
+		],
+		out: ["viewData"],
+		exec: () => {
+			store.setState({ viewData: projectKanbanModel(store.getState()) });
+		}
+	}];
+}
+function projectKanbanModel(state) {
+	const { cards, columns, columnAccessor, filters, sort, dynamicData, columnData } = state;
+	const getColumn = getColumnReader(columnAccessor);
+	const buckets = /* @__PURE__ */ new Map();
+	const knownColumns = new Set(columns.map((column) => column.id));
+	columns.forEach((column) => {
+		buckets.set(column.id, []);
+	});
+	cards.getCards().forEach((card) => {
+		const columnId = getColumn(card);
+		if (knownColumns.has(columnId)) buckets.get(columnId).push(card);
+	});
+	const predicates = Array.from(filters.values());
+	const compare = getComparator(sort);
+	return new KanbanModel({ columns: columns.map((column) => {
+		let columnCards = buckets.get(column.id) || [];
+		if (predicates.length) columnCards = columnCards.filter((card) => predicates.every((predicate) => predicate(card)));
+		else columnCards = columnCards.slice();
+		if (compare) columnCards.sort(compare);
+		return toColumnView(column, columnCards, getColumnStatus(dynamicData, columnData, column.id));
+	}) });
+}
+function getColumnReader(accessor) {
+	return typeof accessor === "string" ? (card) => card[accessor] : accessor.get;
+}
+function getComparator(sort) {
+	if (!sort) return null;
+	if (typeof sort === "function") return sort;
+	const direction = sort.dir === "desc" ? -1 : 1;
+	return (a, b) => {
+		const left = a[sort.field];
+		const right = b[sort.field];
+		if (left === right) return 0;
+		if (left === void 0) return -1 * direction;
+		if (right === void 0) return 1 * direction;
+		if (left < right) return -1 * direction;
+		if (left > right) return 1 * direction;
+		return 0;
+	};
+}
+function getColumnStatus(dynamicData, columnData, id) {
+	return dynamicData ? columnData.get(id)?.status ?? "unknown" : "loaded";
+}
+function toColumnView(column, cards, dataStatus) {
+	const view = {
+		id: column.id,
+		label: column.label,
+		collapsed: column.collapsed ?? false,
+		addCard: column.addCard !== false,
+		overLimit: typeof column.cardLimit === "number" && cards.length > column.cardLimit,
+		dataStatus,
+		cards
+	};
+	if (column.css !== void 0) view.css = column.css;
+	if (column.metadata !== void 0) view.metadata = column.metadata;
+	if (column.cardLimit !== void 0) view.cardLimit = column.cardLimit;
+	return view;
+}
+
+//#endregion
+//#region src/kanban_store.ts
+var KanbanStore = class extends Store {
+	in;
+	meta;
+	_router;
+	constructor(w, options) {
+		super({
+			writable: w,
+			async: false
+		});
+		this.meta = {};
+		this._router = new DataRouter(super.setState.bind(this), reactive(this), {
+			columns: (v) => [...v],
+			cards: (v) => new CardsStore(v)
+		});
+		super.setState({
+			cards: new CardsStore([]),
+			columns: [],
+			columnAccessor: "column",
+			filters: /* @__PURE__ */ new Map(),
+			sort: null,
+			editorData: null,
+			dynamicData: false,
+			columnData: /* @__PURE__ */ new Map(),
+			history: {
+				undo: 0,
+				redo: 0
+			},
+			viewData: new KanbanModel({ columns: [] })
+		});
+		init(this.in = new EventBus(), this);
+	}
+	init(state) {
+		this._router.init(state);
+	}
+	getCards() {
+		return this.getState().cards.getCards();
+	}
+	pushUndo(action, ev) {
+		this._history.pushUndo(action, ev);
+	}
+	undo() {
+		this._history.undo();
+	}
+	redo() {
+		this._history.redo();
+	}
+	resetHistory() {
+		this._history.reset();
+	}
+	getBrandmark() {
+		return null;
+	}
+	setState(state, ctx) {
+		if (state.cards && Array.isArray(state.cards)) state = {
+			...state,
+			cards: new CardsStore(state.cards)
+		};
+		return this._router.setState(state, ctx);
+	}
+};
+
+//#endregion
+//#region src/locale/index.ts
+function locale(initialData) {
+	let data = initialData;
+	return {
+		data,
+		_(key) {
+			return data[key] || key;
+		},
+		__(group, key) {
+			const block = data[group];
+			return block ? block[key] || key : key;
+		},
+		getGroup(group) {
+			return (key) => this.__(group, key);
+		},
+		extend(values) {
+			this.data = data = {
+				...data,
+				...values
+			};
+			return this;
+		}
+	};
+}
+
+//#endregion
+//#region src/constants.ts
+function getMenuOptions() {
+	return [
+		{
+			id: "edit-card",
+			text: "Edit card",
+			icon: "wxi-edit"
+		},
+		{
+			id: "duplicate-card",
+			text: "Duplicate card",
+			icon: "wxi-content-copy"
+		},
+		{
+			id: "delete-card",
+			text: "Delete card",
+			icon: "wxi-delete"
+		}
+	];
+}
+function getToolbarItems(config) {
+	const items = [];
+	if (config?.add) {
+		items.push({
+			id: "add-card",
+			comp: "button",
+			icon: "wxi-plus",
+			type: "primary"
+		});
+		items.push({ comp: "separator" });
+	}
+	if (config?.undo) items.push({
+		id: "undo",
+		comp: "icon",
+		icon: "wxi-undo",
+		title: "Undo",
+		menuText: "Undo"
+	}, {
+		id: "redo",
+		comp: "icon",
+		icon: "wxi-redo",
+		title: "Redo",
+		menuText: "Redo"
+	});
+	if (config?.sort) items.push({
+		text: "Sort",
+		title: "Sort",
+		icon: "wxi-sort",
+		collapsed: true,
+		layout: "column",
+		items: [
+			{
+				id: "sort-label-asc",
+				comp: "item",
+				icon: "wxi-asc",
+				text: "Title A-Z"
+			},
+			{
+				id: "sort-label-desc",
+				comp: "item",
+				icon: "wxi-desc",
+				text: "Title Z-A"
+			},
+			{
+				id: "sort-priority-asc",
+				comp: "item",
+				icon: "wxi-asc",
+				text: "Priority Low-High"
+			},
+			{
+				id: "sort-priority-desc",
+				comp: "item",
+				icon: "wxi-desc",
+				text: "Priority High-Low"
+			},
+			{ comp: "separator" },
+			{
+				id: "sort-clear",
+				comp: "item",
+				text: "Clear sorting"
+			}
+		]
+	});
+	return items;
+}
+
+//#endregion
+export { CardsStore, KanbanModel, KanbanStore, getMenuOptions, getToolbarItems, locale };

package/license.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 XB Software Sp. z o.o.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@svar-ui/kanban-store",
+  "version": "2.6.0",
+  "description": "State and models for SVAR Kanban",
+  "homepage": "https://svar.dev",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/svar-widgets/kanban.git"
+  },
+  "files": [
+    "dist",
+    "license.txt"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@svar-ui/lib-dom": "0.13.1",
+    "@svar-ui/lib-state": "1.9.7"
+  },
+  "devDependencies": {
+    "@svar-ui/lib-state": "1.9.7",
+    "@typescript/native-preview": "7.0.0-dev.20260316.1",
+    "typescript": "^5.9.3",
+    "vite-plus": "0.1.16"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# SVAR Kanban Store
+
+This package is part of the **SVAR Kanban (Open-Source Edition)** functionality and is distributed under the MIT license.
+
+The **kanban-store** package handles the internal state management used by the Kanban component.