@mosaicoo/kanban 0.1.0

package/fesm2022/mosaicoo-kanban.mjs

@@ -0,0 +1,13 @@
+export * from '@mosaicoo/kanban/core';
+export * from '@mosaicoo/kanban/ui';
+
+/*
+ * @mosaicoo/kanban — entry primário: re-exporta o caminho comum (core + ui).
+ *
+ * Consumidores headless usam '@mosaicoo/kanban/core'; integrações de
+ * persistência usam '@mosaicoo/kanban/adapters'.
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@mosaicoo/kanban",
+  "version": "0.1.0",
+  "description": "Flexible board engine and Angular UI for Kanban-style visual organization — configurable columns, swimlanes and dynamic grouping, with a headless zero-dependency core.",
+  "license": "Apache-2.0",
+  "homepage": "https://github.com/mosaicoo/mosaicoo-kanban#readme",
+  "bugs": {
+    "url": "https://github.com/mosaicoo/mosaicoo-kanban/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mosaicoo/mosaicoo-kanban.git"
+  },
+  "keywords": [
+    "kanban",
+    "board",
+    "swimlane",
+    "drag-and-drop",
+    "angular",
+    "headless",
+    "mosaicoo"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    "./styles/*.css": "./styles/*.css",
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/mosaicoo-kanban.d.ts",
+      "default": "./fesm2022/mosaicoo-kanban.mjs"
+    },
+    "./adapters": {
+      "types": "./types/mosaicoo-kanban-adapters.d.ts",
+      "default": "./fesm2022/mosaicoo-kanban-adapters.mjs"
+    },
+    "./core": {
+      "types": "./types/mosaicoo-kanban-core.d.ts",
+      "default": "./fesm2022/mosaicoo-kanban-core.mjs"
+    },
+    "./ui": {
+      "types": "./types/mosaicoo-kanban-ui.d.ts",
+      "default": "./fesm2022/mosaicoo-kanban-ui.mjs"
+    }
+  },
+  "peerDependencies": {
+    "@angular/cdk": ">=21.0.0 <23.0.0",
+    "@angular/common": ">=21.0.0 <23.0.0",
+    "@angular/core": ">=21.0.0 <23.0.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/mosaicoo-kanban.mjs",
+  "typings": "types/mosaicoo-kanban.d.ts",
+  "type": "module"
+}

package/styles/kanban-tokens.css

@@ -0,0 +1,66 @@
+/*
+ * @mosaicoo/kanban — Design Tokens (--mkb-*)
+ * ----------------------------------------------------------------------------
+ * Este arquivo é OPCIONAL. Os componentes já funcionam sem ele, porque todo
+ * uso interno segue a cadeia de fallback (docs/01-arquitetura.md §12):
+ *
+ *   var(--mkb-token, var(--token-do-DS-mosaicoo, default-embutido))
+ *
+ * - Dentro da plataforma Mosaicoo: NÃO importe este arquivo — o tema do DS
+ *   (claro/escuro via [data-theme]) é herdado automaticamente.
+ * - Fora do ecossistema: importe-o para ter o tema default do produto e
+ *   redefina os tokens abaixo para personalizar.
+ *
+ *   import '@mosaicoo/kanban/styles/kanban-tokens.css';
+ */
+
+:root {
+  /* Superfícies e bordas */
+  --mkb-surface: #f6f5f8;        /* fundo do board */
+  --mkb-column-bg: #efedf3;      /* fundo de coluna */
+  --mkb-card-bg: #ffffff;        /* fundo de cartão */
+  --mkb-border: #e3e0ea;
+  --mkb-border-strong: #c9c4d4;
+
+  /* Texto */
+  --mkb-foreground: #241f33;
+  --mkb-muted: #6f6a7c;
+
+  /* Marca / realce (violeta Mosaicoo como default de fábrica) */
+  --mkb-accent: #5e35b1;
+  --mkb-accent-contrast: #ffffff;
+
+  /* Estados */
+  --mkb-danger: #b3261e;
+  --mkb-warning: #9a6b00;
+  --mkb-success: #1b6e3c;
+
+  /* Forma e tipografia */
+  --mkb-radius: 10px;
+  --mkb-radius-sm: 6px;
+  --mkb-font: system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
+
+  /* Densidade / espaçamentos (docs/02 §10 — configuráveis pelo host) */
+  --mkb-gap: 12px;               /* base p/ colunas e lanes (retrocompat) */
+  --mkb-column-gap: var(--mkb-gap);  /* horizontal entre colunas */
+  --mkb-lane-gap: var(--mkb-gap);    /* vertical entre lanes */
+  --mkb-card-gap: 8px;           /* entre cartões */
+  --mkb-entry-gap: 4px;          /* entre itens internos (entries) do card */
+  --mkb-block-gap: 8px;          /* entre blocos do cartão declarativo */
+  --mkb-fact-gap: 10px;          /* entre fatos inline (facts) */
+  --mkb-card-padding: 10px 12px; /* interno do cartão */
+  --mkb-cell-padding: 4px 8px 10px;  /* interno do container de cartões */
+  --mkb-header-padding: 10px 12px;   /* interno do cabeçalho de coluna/lane */
+  --mkb-lane-label-width: 140px;     /* largura do rótulo da lane na grade */
+  --mkb-column-width: clamp(220px, 26vw, 320px);  /* largura da coluna */
+  /* colunas da grade de lanes: por padrão, MESMA largura das colunas */
+  --mkb-grid-column-width: var(--mkb-column-width);
+
+  /* Movimento */
+  --mkb-dur: 150ms;
+  --mkb-dur-move: 180ms;         /* reordenação/settle (FLIP) */
+  --mkb-ease: cubic-bezier(0.2, 0, 0, 1);
+
+  /* Foco (a11y) */
+  --mkb-focus-ring: 0 0 0 3px color-mix(in srgb, var(--mkb-accent) 35%, transparent);
+}

package/types/mosaicoo-kanban-adapters.d.ts

@@ -0,0 +1,166 @@
+import { KanbanItem, CellRef, KanbanAxis, KanbanEntry, EntryRef, BoardConfig, KanbanBoard, CreateBoardOptions } from '@mosaicoo/kanban/core';
+
+/**
+ * Mudança de dados do board, SERIALIZÁVEL — é o que viaja para o adapter
+ * (persistência) e o que chega dele (tempo real).
+ *
+ * `items` é o snapshot completo dos itens APÓS a mudança: adapters de
+ * snapshot (localStorage, arquivo) salvam direto; adapters granulares
+ * (REST) usam os campos específicos e ignoram o snapshot.
+ */
+type KanbanChange = {
+    items: readonly KanbanItem[];
+} & ({
+    type: 'move';
+    item: KanbanItem;
+    from: CellRef;
+    to: CellRef;
+} | {
+    type: 'add';
+    item: KanbanItem;
+} | {
+    type: 'update';
+    item: KanbanItem;
+    previous: KanbanItem;
+    changes: Record<string, unknown>;
+} | {
+    type: 'remove';
+    item: KanbanItem;
+} | {
+    type: 'move-group';
+    axis: KanbanAxis;
+    groupId: string;
+    from: number;
+    to: number;
+    /** Nova ordem completa dos ids do eixo (para adapters de snapshot). */
+    order: readonly string[];
+} | {
+    type: 'move-entry';
+    entry: KanbanEntry;
+    from: EntryRef;
+    to: EntryRef;
+} | {
+    type: 'update-entry';
+    op: 'add' | 'update' | 'remove';
+    cardId: string;
+    field: string;
+    entry: KanbanEntry;
+    previous?: KanbanEntry;
+    changes?: Record<string, unknown>;
+});
+/**
+ * Contrato de persistência (docs/01 §7-8). O host entrega o adapter JÁ
+ * contextualizado (URL/chaves do tenant corrente, quando aplicável) — a lib
+ * não conhece tenant nem autenticação e NUNCA persiste por conta própria.
+ */
+interface KanbanDataAdapter {
+    /** Carrega a configuração completa do board (com os itens). */
+    load(): Promise<BoardConfig>;
+    /** Persiste uma mudança aplicada localmente (fluxo otimista: a UI já
+     * refletiu; rejeição gera rollback automático no binder). */
+    persist(change: KanbanChange): Promise<void>;
+    /**
+     * Tempo real (opcional): o adapter chama `push` a cada evento REMOTO
+     * (nunca com eco das mudanças locais); retorna a função de desinscrição.
+     */
+    connect?(push: (change: KanbanChange) => void): () => void;
+}
+
+interface BindAdapterOptions {
+    /** Desfazer localmente a mudança cujo persist foi rejeitado (default true). */
+    rollbackOnError?: boolean;
+    /** Notificação de falha de persistência (toast/log do host). */
+    onPersistError?(error: unknown, change: KanbanChange): void;
+}
+/**
+ * Liga um board a um adapter (docs/01 §7):
+ *
+ * - FLUXO OTIMISTA: cada after:* vira um KanbanChange e entra numa FILA
+ *   sequencial de persist (ordem garantida); rejeição → rollback automático
+ *   via applyRemote (fora do histórico de undo) + onPersistError.
+ * - TEMPO REAL: se o adapter tem connect(), eventos remotos entram como
+ *   applyRemote — não disparam persist (sem eco), não entram no undo local
+ *   e não passam por regras/permissões (last-write-wins, o evento já
+ *   aconteceu na origem).
+ *
+ * Retorna a função que desliga tudo (chamar antes de board.destroy()).
+ */
+declare function bindAdapter(board: KanbanBoard, adapter: KanbanDataAdapter, options?: BindAdapterOptions): () => void;
+/**
+ * Caminho feliz: carrega a config do adapter, cria o board (validação do
+ * createBoard incluída) e já liga a persistência/tempo real.
+ */
+declare function loadBoard(adapter: KanbanDataAdapter, options?: CreateBoardOptions & BindAdapterOptions): Promise<KanbanBoard>;
+
+interface MemoryAdapterOptions {
+    /** Simula rejeição do backend para a mudança (testes/demos de rollback). */
+    failOn?(change: KanbanChange): boolean;
+}
+/**
+ * Adapter em memória — referência para demos e testes. Guarda a config como
+ * fonte da verdade e aceita `emitRemote()` para simular um evento vindo do
+ * servidor (exercita o caminho de tempo real sem rede).
+ */
+declare class MemoryKanbanAdapter implements KanbanDataAdapter {
+    private readonly options;
+    private config;
+    private readonly pushes;
+    constructor(seed: BoardConfig, options?: MemoryAdapterOptions);
+    load(): Promise<BoardConfig>;
+    persist(change: KanbanChange): Promise<void>;
+    connect(push: (change: KanbanChange) => void): () => void;
+    /** Simula um evento REMOTO: atualiza a fonte da verdade e avisa os
+     * conectados (como um servidor faria). */
+    emitRemote(change: KanbanChange): void;
+    /** Itens atualmente persistidos (inspeção em testes). */
+    get items(): readonly KanbanItem[];
+}
+
+/**
+ * Adapter de localStorage — referência de persistência local (playground,
+ * protótipos). A CHAVE vem pronta do host (é ele que contextualiza tenant/
+ * usuário, docs/01 §8); a lib não inventa chave nenhuma.
+ *
+ * Tempo real de verdade entre ABAS: o evento nativo 'storage' só dispara nas
+ * outras abas — cada gravação local vira push remoto para as demais.
+ */
+declare class LocalStorageKanbanAdapter implements KanbanDataAdapter {
+    private readonly storageKey;
+    private readonly seed;
+    constructor(storageKey: string, seed: BoardConfig);
+    load(): Promise<BoardConfig>;
+    persist(change: KanbanChange): Promise<void>;
+    connect(push: (change: KanbanChange) => void): () => void;
+    /** Apaga o estado salvo (ex.: botão "resetar demo" do host). */
+    clear(): void;
+    private read;
+}
+
+interface RestAdapterOptions {
+    /** GET daqui deve devolver um BoardConfig (JSON). */
+    loadUrl: string;
+    /** POST para cá recebe o KanbanChange (JSON). */
+    persistUrl: string;
+    /** Headers extras (ex.: Authorization) — o host entrega prontos. */
+    headers?: Record<string, string>;
+    /** Injetável para testes/ambientes sem fetch global. */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Adapter REST de referência — ESQUELETO documentado (docs/01 §7): dois
+ * endpoints, payloads JSON diretos. Casos reais tendem a envolver mapeamento
+ * de DTOs, autenticação e retry — faça um adapter próprio usando este como
+ * molde. Tempo real (connect) fica com o host: WebSocket/SSE são específicos
+ * demais para uma referência genérica; veja LocalStorageKanbanAdapter para o
+ * formato do push.
+ */
+declare class RestKanbanAdapter implements KanbanDataAdapter {
+    private readonly options;
+    constructor(options: RestAdapterOptions);
+    load(): Promise<BoardConfig>;
+    persist(change: KanbanChange): Promise<void>;
+    private doFetch;
+}
+
+export { LocalStorageKanbanAdapter, MemoryKanbanAdapter, RestKanbanAdapter, bindAdapter, loadBoard };
+export type { BindAdapterOptions, KanbanChange, KanbanDataAdapter, MemoryAdapterOptions, RestAdapterOptions };