@svar-ui/kanban-provider 2.6.0

package/dist/index.d.mts

@@ -0,0 +1,205 @@
+//#region ../../node_modules/.pnpm/@svar-ui+lib-state@1.9.6/node_modules/@svar-ui/lib-state/dist/index.d.ts
+interface IEventConfig {
+  intercept?: boolean;
+  tag?: number | string | symbol;
+}
+interface IEventBus<T> {
+  exec(name: keyof T, ev: T[keyof T]): Promise<T[keyof T]>;
+  setNext(next: IEventBus<T>): IEventBus<T>;
+}
+declare class EventBus<T, A extends keyof T> {
+  private _handlers;
+  protected _nextHandler: IEventBus<T>;
+  protected _tag: WeakMap<{
+    (v: T[A]): void | boolean | Promise<boolean>;
+  }, number | string | symbol>;
+  constructor();
+  on(name: A, handler: (v: T[A]) => void | boolean | Promise<boolean>, config?: IEventConfig): void;
+  intercept(name: A, handler: (v: T[A]) => void | boolean | Promise<boolean>, config?: IEventConfig): void;
+  detach(tag: number | string | symbol): void;
+  exec(name: A, ev: T[A]): Promise<T[A]>;
+  setNext(next: IEventBus<T>): IEventBus<T>;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@svar-ui+lib-data-provider@1.7.2/node_modules/@svar-ui/lib-data-provider/dist/index.d.ts
+type Action = {
+  ignoreID?: boolean;
+  debounce?: number;
+  handler: Handler;
+};
+type ActionMap<T> = { [P in keyof T]?: Action };
+type DataObj = {
+  [key: string]: any;
+};
+type Handler = (data: DataObj, action: string, ev: any) => Promise<any>;
+type HandlerConfig = {
+  resolve?: (v: boolean) => void;
+  reject?: (e: any) => void;
+  timer?: number;
+  kind?: number;
+  debounce?: number;
+  ignoreID?: boolean;
+  handler: Handler;
+};
+type RestDataProviderConfig = {
+  batchURL?: string;
+};
+type TID = string | number;
+type ServerResponse = {
+  id?: TID;
+};
+declare class ActionQueue {
+  private _awaitAddingQueue;
+  private _queue;
+  private _idPool;
+  private _backId;
+  private _status;
+  private _waitPull;
+  constructor();
+  reset(ids?: boolean): void;
+  resolve(id: TID, type: number): TID;
+  getSync(): number;
+  waitSync(): Promise<void>;
+  getId(id: TID): TID | null;
+  waitId(id: TID): Promise<TID>;
+  add(action: string, data: DataObj, proc: HandlerConfig): Promise<boolean>;
+  tryExec(action: string, data: DataObj, proc: HandlerConfig, finish?: () => void): boolean;
+  exec(action: string, data: DataObj, proc: HandlerConfig, finish?: () => void): Promise<ServerResponse> | null;
+  correctID(obj: DataObj, ignore: TID): DataObj | symbol;
+  execQueue(): void;
+  private _finishQueue;
+}
+declare class Rest<T> extends EventBus<T, keyof T> {
+  private _queue;
+  private _customHeaders;
+  protected _url: string;
+  protected _batchUrl?: string;
+  private _batchQueue;
+  private _batchTimeout;
+  constructor(url?: string, config?: Partial<RestDataProviderConfig>);
+  getHandlers(): ActionMap<T>;
+  setHeaders(headers: Record<string, string>): void;
+  getQueue(): ActionQueue;
+  send(url: string, method: string, data?: object, customHeaders?: Record<string, string>): Promise<T>;
+  private sendBatchRequest;
+  protected toPayload(obj: object): string;
+  protected sendRequest<T>(url: string, method: string, data?: string | object, customHeaders?: Record<string, string>): Promise<T>;
+}
+//#endregion
+//#region ../store/dist/index.d.mts
+type CardID = string | number;
+type ColumnID = string | number;
+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 SortCriterion = ((a: KanbanCard, b: KanbanCard) => number) | {
+  field: string;
+  dir?: "asc" | "desc";
+} | null;
+type FilterPredicate = (card: KanbanCard) => boolean;
+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 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
+//#endregion
+//#region src/RestDataProvider.d.ts
+type TMethodsConfig = Pick<StoreActions, "add-card" | "update-card" | "delete-card" | "move-card" | "duplicate-card">;
+declare class RestDataProvider extends Rest<TMethodsConfig> {
+  getHandlers(): ActionMap<TMethodsConfig>;
+  getData(): Promise<KanbanCard[]>;
+  parseCards(data: KanbanCard[]): KanbanCard[];
+  protected toPayload(obj: object): string;
+  formatDate(date: Date): string;
+}
+//#endregion
+export { RestDataProvider };

package/dist/index.mjs

@@ -0,0 +1,326 @@
+(/* @__PURE__ */ new Date()).valueOf();
+function isTempID(v) {
+	return typeof v === "string" && v.length === 20 && parseInt(v.substr(7)) > 0xe8d4a51000;
+}
+var EventBus = class {
+	constructor() {
+		this._nextHandler = null;
+		this._handlers = {};
+		this._tag = /* @__PURE__ */ new WeakMap();
+		this.exec = this.exec.bind(this);
+	}
+	on(name, handler, config) {
+		let prev = this._handlers[name];
+		if (!prev) prev = this._handlers[name] = [handler];
+		else if (config && config.intercept) prev.unshift(handler);
+		else prev.push(handler);
+		if (config && config.tag) this._tag.set(handler, config.tag);
+	}
+	intercept(name, handler, config) {
+		this.on(name, handler, {
+			...config,
+			intercept: true
+		});
+	}
+	detach(tag) {
+		for (const key in this._handlers) {
+			const stack = this._handlers[key];
+			for (let i = stack.length - 1; i >= 0; i--) if (this._tag.get(stack[i]) === tag) stack.splice(i, 1);
+		}
+	}
+	async exec(name, ev) {
+		const stack = this._handlers[name];
+		if (stack) for (let i = 0; i < stack.length; i++) {
+			const res = stack[i](ev);
+			if (res === false) return;
+			if (res && res.then) {
+				if (await res === false) return;
+			}
+		}
+		if (this._nextHandler) await this._nextHandler.exec(name, ev);
+		return ev;
+	}
+	setNext(next) {
+		return this._nextHandler = next;
+	}
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@svar-ui+lib-data-provider@1.7.2/node_modules/@svar-ui/lib-data-provider/dist/index.js
+var cantSendYet = Symbol();
+var ActionQueue = class {
+	constructor() {
+		this.reset(true);
+	}
+	reset(ids = false) {
+		this._awaitAddingQueue = [];
+		this._queue = {};
+		this._waitPull = {};
+		this._status = [];
+		if (ids) {
+			this._idPool = {};
+			this._backId = [];
+		}
+	}
+	resolve(id, type) {
+		const col = this._backId[type];
+		if (typeof col === "undefined") return id;
+		const tID = col[id];
+		return typeof tID === "undefined" ? id : tID;
+	}
+	getSync() {
+		const t = this._awaitAddingQueue;
+		if (!t.length) return 0;
+		for (let i = 0; i < t.length; i++) if (!t[i].sent) return 1;
+		return 2;
+	}
+	waitSync() {
+		return new Promise((resolve) => {
+			if (this.getSync() === 0) resolve();
+			else this._status.push(resolve);
+		});
+	}
+	getId(id) {
+		return this._idPool[id] || (isTempID(id) ? null : id);
+	}
+	waitId(id) {
+		return new Promise((resolve) => {
+			const sid = this.getId(id);
+			if (sid !== null) resolve(sid);
+			const warr = this._waitPull[id] || [];
+			warr.push(resolve);
+			this._waitPull[id] = warr;
+		});
+	}
+	add(action, data, proc) {
+		return new Promise((resolve, reject) => {
+			proc = {
+				...proc,
+				resolve,
+				reject
+			};
+			if (proc.debounce) {
+				const qid = `${action}"/"${data.id}`;
+				const item = this._queue[qid];
+				if (item) {
+					proc.resolve = (v) => {
+						item.resolve(v);
+						resolve(v);
+					};
+					proc.reject = (e) => {
+						item.reject(e);
+						reject();
+					};
+					clearTimeout(item.timer);
+				}
+				this._queue[qid] = proc;
+				proc.timer = setTimeout(() => {
+					this.tryExec(action, data, proc);
+				}, proc.debounce);
+				return;
+			}
+			this.tryExec(action, data, proc);
+		});
+	}
+	tryExec(action, data, proc, finish) {
+		const ready = this.exec(action, data, proc, finish);
+		if (ready === null) {
+			if (!finish) this._awaitAddingQueue.push({
+				action,
+				data,
+				proc
+			});
+			return false;
+		}
+		ready.then((res) => {
+			const check = res && res.id && res.id != data.id && isTempID(data.id);
+			if (check) {
+				this._idPool[data.id] = res.id;
+				if (this._waitPull[data.id]) {
+					this._waitPull[data.id].forEach((v) => v(res.id));
+					delete this._waitPull[data.id];
+				}
+				if (proc.kind) {
+					let t = this._backId[proc.kind];
+					if (!t) t = this._backId[proc.kind] = {};
+					t[res.id] = data.id;
+				}
+			}
+			data.response = res;
+			proc.resolve(true);
+			if (finish) finish();
+			if (check) this.execQueue();
+		}, (e) => {
+			if (finish) finish();
+			proc.reject(e);
+		});
+		return true;
+	}
+	exec(action, data, proc, finish) {
+		const correctData = this.correctID(data, proc.ignoreID ? data.id : null);
+		if (correctData === cantSendYet) return null;
+		let res;
+		try {
+			res = proc.handler(correctData, action, data);
+		} catch (e) {
+			finish();
+			proc.reject(e);
+		}
+		return res;
+	}
+	correctID(obj, ignore) {
+		let copy = null;
+		for (const key in obj) {
+			const test = obj[key];
+			if (typeof test === "object") {
+				const after = this.correctID(test, ignore);
+				if (after !== test) {
+					if (after === cantSendYet) return cantSendYet;
+					if (copy === null) copy = { ...obj };
+					copy[key] = after;
+				}
+			} else if (isTempID(test)) {
+				const hasRealID = this._idPool[test];
+				if (hasRealID) {
+					if (copy === null) copy = { ...obj };
+					copy[key] = hasRealID;
+				} else if (!ignore) return cantSendYet;
+			}
+		}
+		return copy || obj;
+	}
+	execQueue() {
+		this._awaitAddingQueue.forEach((a) => {
+			if (!a.sent) {
+				const finish = () => this._finishQueue(a);
+				if (this.tryExec(a.action, a.data, a.proc, finish)) a.sent = true;
+			}
+		});
+	}
+	_finishQueue(a) {
+		this._awaitAddingQueue = this._awaitAddingQueue.filter((v) => v !== a);
+		if (!this._awaitAddingQueue.length && this._status.length) {
+			const temp = [...this._status];
+			this._status = [];
+			temp.forEach((resolve) => resolve());
+		}
+	}
+};
+var Rest = class extends EventBus {
+	constructor(url, config) {
+		super();
+		this._customHeaders = {};
+		this._batchQueue = [];
+		this._batchTimeout = null;
+		this._url = url;
+		this._batchUrl = config?.batchURL;
+		this._queue = new ActionQueue();
+		const handlers = this.getHandlers();
+		for (const x in handlers) this.on(x, (ev) => {
+			if (!ev.skipProvider) return this._queue.add(x, ev, handlers[x]);
+		});
+	}
+	getHandlers() {
+		return {};
+	}
+	setHeaders(headers) {
+		this._customHeaders = headers;
+	}
+	getQueue() {
+		return this._queue;
+	}
+	async send(url, method, data, customHeaders = {}) {
+		if (this._batchUrl && method !== "GET") return this.sendBatchRequest(url, method, data, customHeaders);
+		else return this.sendRequest(url, method, data, customHeaders);
+	}
+	async sendBatchRequest(url, method, data, customHeaders) {
+		return new Promise((resolve) => {
+			this._batchQueue.push({
+				url,
+				method,
+				data,
+				resolve
+			});
+			if (this._batchTimeout) clearTimeout(this._batchTimeout);
+			this._batchTimeout = setTimeout(async () => {
+				const currentQueue = [...this._batchQueue];
+				this._batchQueue = [];
+				if (currentQueue.length > 1) {
+					const batchData = currentQueue.map((req) => ({
+						url: req.url,
+						method: req.method,
+						data: { ...req.data }
+					}));
+					const results = await this.sendRequest(this._batchUrl, "POST", batchData);
+					currentQueue.forEach((q, i) => q.resolve(results[i]));
+				} else resolve(await this.sendRequest(url, method, data, customHeaders));
+			}, 10);
+		});
+	}
+	toPayload(obj) {
+		return JSON.stringify(obj);
+	}
+	async sendRequest(url, method, data, customHeaders = {}) {
+		const req = {
+			method,
+			headers: {
+				"Content-Type": "application/json",
+				...customHeaders,
+				...this._customHeaders
+			}
+		};
+		if (data) req.body = typeof data === "object" ? this.toPayload(data) : data;
+		const slash = !url || this._url.endsWith("/") || url[0] === "/" ? "" : "/";
+		return fetch(`${this._url}${slash}${url || ""}`, req).then((res) => res.json());
+	}
+};
+//#endregion
+//#region src/RestDataProvider.ts
+var RestDataProvider = class extends Rest {
+	getHandlers() {
+		return {
+			"add-card": {
+				ignoreID: true,
+				handler: async (data) => {
+					return this.send("cards", "POST", data.card);
+				}
+			},
+			"update-card": {
+				debounce: 500,
+				handler: async (data) => {
+					return this.send(`cards/${data.id}`, "PUT", data.card);
+				}
+			},
+			"move-card": { handler: async (data) => {
+				return this.send(`cards/${data.id}/move`, "PUT", data);
+			} },
+			"delete-card": { handler: async (data) => this.send(`cards/${data.id}`, "DELETE") },
+			"duplicate-card": {
+				ignoreID: true,
+				handler: async (data) => {
+					return this.send(`cards/${data.id}/duplicate`, "POST", data.card);
+				}
+			}
+		};
+	}
+	async getData() {
+		const cards = await this.send("cards", "GET");
+		return this.parseCards(cards);
+	}
+	parseCards(data) {
+		data.forEach((item) => {
+			if (item.deadline) item.deadline = new Date(item.deadline);
+		});
+		return data;
+	}
+	toPayload(obj) {
+		return JSON.stringify(obj, (_key, value) => {
+			if (value instanceof Date) return this.formatDate(value);
+			return value;
+		});
+	}
+	formatDate(date) {
+		return date.toISOString();
+	}
+};
+//#endregion
+export { RestDataProvider };

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,35 @@
+{
+  "name": "@svar-ui/kanban-provider",
+  "version": "2.6.0",
+  "description": "Data provider and REST proxy for the SVAR Kanban",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "license.txt"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@svar-ui/lib-data-provider": "1.7.2",
+    "@typescript/native-preview": "7.0.0-dev.20260316.1",
+    "typescript": "^5.9.3",
+    "vite-plus": "0.1.16",
+    "@svar-ui/kanban-store": "2.6.0"
+  },
+  "inlinedDependencies": {
+    "@svar-ui/lib-data-provider": "1.7.2",
+    "@svar-ui/lib-state": "1.9.6"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  }
+}