@riebeckite/plugin-kanban 0.0.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright Rerurate_514
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,116 @@
+# @riebeckite/plugin-kanban
+
+Render Obsidian Kanban boards as static HTML at build time. No client-side
+JavaScript is required.
+
+[日本語](./README_ja.md)
+
+## Overview
+
+`kanban()` turns kanban markdown into a board. It accepts two kinds of input:
+
+- The body of a ` ```kanban ` fenced code block.
+- A whole note whose frontmatter contains `kanban-plugin` (enabled by
+  `autoDetect`, on by default).
+
+Columns are lines that start with `## ` (configurable with `columnMarker`).
+Every list item that follows becomes a card: `- [ ] text` (unchecked),
+`- [x] text` (checked), or a plain `- text` item.
+
+Card text supports inline `[[wikilinks]]` (resolved to real hrefs from the
+content manifest), `#tags`, and simple `**bold**` emphasis.
+
+## Usage
+
+```ts
+import { defineConfig } from "@riebeckite/core";
+import { kanban } from "@riebeckite/plugin-kanban";
+
+export default defineConfig({
+  // ...
+  plugins: [kanban()],
+});
+```
+
+## Board syntax
+
+````md
+## Backlog
+
+- [ ] Draft the release notes
+- [ ] Link to [[index]]
+- [x] Review **metadata**
+
+## Done
+
+- [x] Publish the fixture
+````
+
+A note that is itself a board looks the same, with the board written directly
+in the body and `kanban-plugin` set in the frontmatter:
+
+```md
+---
+title: Roadmap
+kanban-plugin: board
+---
+
+## Planned
+
+- [ ] Ship the plugin
+```
+
+## Output
+
+```html
+<div class="rb-kanban" data-kanban data-kanban-plugin data-kanban-source="note">
+  <div class="rb-kanban__board" data-kanban-board>
+    <div class="rb-kanban__column" data-column="Backlog">
+      <header class="rb-kanban__column-title">Backlog</header>
+      <ul class="rb-kanban__cards">
+        <li class="rb-kanban__card" data-checked="false">
+          <span class="rb-kanban__checkbox" data-checked="false" aria-hidden="true"></span>
+          <span class="rb-kanban__card-text">Draft the release notes</span>
+        </li>
+      </ul>
+    </div>
+  </div>
+</div>
+```
+
+`data-kanban-source` is `"block"` for a fenced block and `"note"` for an
+auto-detected note.
+
+## Options
+
+| Option | Type | Default | Description |
+| --- | --- | --- | --- |
+| `className` | `string` | `"rb-kanban"` | Root CSS class; block names derive from it |
+| `language` | `string` | `"kanban"` | Fence language to target |
+| `columnMarker` | `string` | `"##"` | Prefix that starts a column |
+| `autoDetect` | `boolean` | `true` | Render notes with `kanban-plugin` frontmatter |
+| `fallback` | `boolean` | `true` | Keep unsupported lines in a `<details>` fallback |
+
+## Fallback and diagnostics
+
+Lines that are neither a column nor a list item are kept verbatim inside
+`details.rb-kanban__fallback` when `fallback` is enabled, so nothing is lost.
+
+Parse problems (for example a block with no columns) are attached to the
+document with a `@riebeckite/plugin-kanban` message.
+
+## Exports
+
+- `kanban(options?)` — plugin factory
+- `kanbanPlugin` — alias of `kanban`
+- `resolveKanbanOptions(options?)` — apply defaults
+- `remarkKanban(options?)` — remark transform used by the plugin
+- `parseKanban(source, options)`, `renderKanban(result, options, resolveLink, source)`
+- `stripFrontmatter(markdown)`, `isKanbanNote(frontmatter)`
+- `createKanbanLinkResolver(manifest)`, `createKanbanPlaceholder(source)`
+- Types: `KanbanOptions`, `ResolvedKanbanOptions`, `KanbanCard`, `KanbanColumn`,
+  `KanbanParseResult`, `KanbanLinkResolver`, `RemarkKanbanOptions`
+
+## See also
+
+- [Plugin guide](../../../docs/en/plugin-system.md)

package/README_ja.md

@@ -0,0 +1,106 @@
+# @riebeckite/plugin-kanban
+
+Obsidian の Kanban ボードを、ビルド時に静的 HTML へ変換するプラグインです。クライアント側の JavaScript は不要です。
+
+[English](./README.md)
+
+## 使い方
+
+`kanban()` をプラグインに追加します。
+
+```ts
+import { defineConfig } from "@riebeckite/core";
+import { kanban } from "@riebeckite/plugin-kanban";
+
+export default defineConfig({
+  // ...
+  plugins: [kanban()],
+});
+```
+
+## ボードの書き方
+
+入力は次の2通りです。
+
+- ` ```kanban ` のフェンスコードブロックの本文
+- フロントマターに `kanban-plugin` を持つノートの本文（`autoDetect`、既定で有効）
+
+どちらも本文の書き方は同じです。`## `（`columnMarker` で変更可）で始まる行が列を区切り、その後に続くリスト項目がカードになります。カードは `- [ ]`（未完了）、`- [x]`（完了）、`- テキスト`（チェックボックスなし）をそのまま扱います。
+
+````md
+## Backlog
+
+- [ ] リリースノートの下書き
+- [ ] [[index]] へのリンクを張る
+- [x] **メタデータ**を確認する
+
+## Done
+
+- [x] フィクスチャを公開する
+````
+
+ノート全体をボードにする場合は、本文に同じ内容を書き、フロントマターに `kanban-plugin` を追加します。
+
+```md
+---
+title: Roadmap
+kanban-plugin: board
+---
+
+## Planned
+
+- [ ] プラグインを公開する
+```
+
+カードのテキストでは `[[ウィキリンク]]`（マニフェストから実際の href に解決）、`#タグ`、`**太字**` を使えます。
+
+## 出力
+
+```html
+<div class="rb-kanban" data-kanban data-kanban-plugin data-kanban-source="note">
+  <div class="rb-kanban__board" data-kanban-board>
+    <div class="rb-kanban__column" data-column="Backlog">
+      <header class="rb-kanban__column-title">Backlog</header>
+      <ul class="rb-kanban__cards">
+        <li class="rb-kanban__card" data-checked="false">
+          <span class="rb-kanban__checkbox" data-checked="false" aria-hidden="true"></span>
+          <span class="rb-kanban__card-text">リリースノートの下書き</span>
+        </li>
+      </ul>
+    </div>
+  </div>
+</div>
+```
+
+`data-kanban-source` は、フェンスブロックなら `"block"`、自動検出したノートなら `"note"` です。
+
+## オプション
+
+| オプション | 型 | 既定値 | 内容 |
+| --- | --- | --- | --- |
+| `className` | `string` | `"rb-kanban"` | ルートの CSS クラス。各要素のクラス名はこれを基に組み立てる |
+| `language` | `string` | `"kanban"` | 対象のフェンス言語 |
+| `columnMarker` | `string` | `"##"` | 列の始まりを示す接頭辞 |
+| `autoDetect` | `boolean` | `true` | `kanban-plugin` を持つノートをボードとして描画する |
+| `fallback` | `boolean` | `true` | 解釈できなかった行を `<details>` に残す |
+
+## フォールバックと診断
+
+列でもリスト項目でもない行は、`fallback` を切らない限り `details.rb-kanban__fallback` にそのまま残ります。取りこぼしはありません。
+
+列が1つもないなど解析に問題がある場合は、`@riebeckite/plugin-kanban` を発行元とするメッセージを文書に付与します。
+
+## エクスポート
+
+- `kanban(options?)` — プラグインファクトリ
+- `kanbanPlugin` — `kanban` の別名
+- `resolveKanbanOptions(options?)` — 既定値を適用する
+- `remarkKanban(options?)` — プラグインが使う Remark 変換
+- `parseKanban(source, options)` と `renderKanban(result, options, resolveLink, source)`
+- `stripFrontmatter(markdown)` と `isKanbanNote(frontmatter)`
+- `createKanbanLinkResolver(manifest)` と `createKanbanPlaceholder(source)`
+- 型: `KanbanOptions`、`ResolvedKanbanOptions`、`KanbanCard`、`KanbanColumn`、`KanbanParseResult`、`KanbanLinkResolver`、`RemarkKanbanOptions`
+
+## 関連資料
+
+- [プラグインガイド](../../../docs/ja/plugin-system.md)

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+import { type KanbanOptions } from "./src/types.js";
+export { isKanbanNote, parseKanban, stripFrontmatter } from "./src/parse.js";
+export type { KanbanCard, KanbanColumn, KanbanParseResult, } from "./src/parse.js";
+export { KANBAN_ATTRIBUTE, createKanbanPlaceholder, createKanbanPlaceholderPattern, decodeKanbanSource, encodeKanbanSource, } from "./src/placeholder.js";
+export { createKanbanLinkResolver, renderKanban } from "./src/render.js";
+export type { KanbanLink, KanbanLinkResolver, KanbanSource, } from "./src/render.js";
+export { remarkKanban } from "./src/remark.js";
+export type { RemarkKanbanOptions } from "./src/remark.js";
+export { resolveKanbanOptions } from "./src/types.js";
+export type { KanbanOptions, ResolvedKanbanOptions } from "./src/types.js";
+export declare function kanban(options?: KanbanOptions): import("@riebeckite/core").RiebeckitePlugin<KanbanOptions>;
+export declare const kanbanPlugin: typeof kanban;

package/dist/index.js

@@ -0,0 +1,329 @@
+// index.ts
+import {
+  createStyleAsset,
+  definePlugin
+} from "@riebeckite/core";
+
+// src/remark.ts
+import { visit } from "unist-util-visit";
+
+// src/parse.ts
+var LIST_ITEM = /^\s*[-*+]\s+(.*)$/;
+var TASK_MARKER = /^\[([ xX])\]\s*(.*)$/;
+function parseKanban(source, options) {
+  const columns = [];
+  const fallback = [];
+  const problems = [];
+  const heading = new RegExp(
+    `^\\s*${escapeRegExp(options.columnMarker)}\\s+(.+?)\\s*$`
+  );
+  let current = null;
+  for (const rawLine of source.replace(/\r\n?/g, "\n").split("\n")) {
+    const line = rawLine.replace(/\s+$/, "");
+    if (line.trim() === "") continue;
+    const columnName = line.match(heading)?.[1]?.trim();
+    if (columnName) {
+      current = { name: columnName, cards: [] };
+      columns.push(current);
+      continue;
+    }
+    const item = line.match(LIST_ITEM)?.[1]?.trim();
+    if (item !== void 0) {
+      if (item === "") {
+        fallback.push(line);
+        continue;
+      }
+      const card = parseCard(item);
+      if (current) {
+        current.cards.push(card);
+      } else {
+        fallback.push(line);
+        problems.push(
+          "A card appeared before the first column and was kept in the fallback."
+        );
+      }
+      continue;
+    }
+    fallback.push(line);
+  }
+  if (columns.length === 0) {
+    problems.push(
+      `No columns were found (expected a line starting with "${options.columnMarker} ").`
+    );
+  }
+  return { columns, fallback, problems };
+}
+function isKanbanNote(frontmatter) {
+  return typeof frontmatter === "object" && frontmatter !== null && Object.hasOwn(frontmatter, "kanban-plugin");
+}
+function stripFrontmatter(markdown) {
+  return markdown.replace(
+    /^\uFEFF?(?:---|\+\+\+)\r?\n[\s\S]*?\r?\n(?:---|\+\+\+)[ \t]*\r?\n?/,
+    ""
+  );
+}
+function parseCard(text) {
+  const task = text.match(TASK_MARKER);
+  if (task) {
+    return {
+      checked: task[1]?.toLowerCase() === "x",
+      text: (task[2] ?? "").trim()
+    };
+  }
+  return { checked: false, text: text.trim() };
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/placeholder.ts
+var KANBAN_ATTRIBUTE = "data-rr-kanban";
+function encodeKanbanSource(source) {
+  return encodeURIComponent(source);
+}
+function decodeKanbanSource(encoded) {
+  return decodeURIComponent(encoded);
+}
+function createKanbanPlaceholder(source) {
+  return `<div ${KANBAN_ATTRIBUTE}="${encodeKanbanSource(source)}"></div>`;
+}
+function createKanbanPlaceholderPattern() {
+  return new RegExp(
+    `<div\\b[^>]*\\b${KANBAN_ATTRIBUTE}="([^"]*)"[^>]*>\\s*</div>`,
+    "g"
+  );
+}
+
+// src/types.ts
+function resolveKanbanOptions(options = {}) {
+  return {
+    className: options.className?.trim() || "rb-kanban",
+    language: options.language?.trim() || "kanban",
+    columnMarker: options.columnMarker?.trim() || "##",
+    autoDetect: options.autoDetect ?? true,
+    fallback: options.fallback ?? true
+  };
+}
+
+// src/remark.ts
+function remarkKanban(options = {}) {
+  const resolved = resolveKanbanOptions(options);
+  return (tree, file) => {
+    if (resolved.autoDetect && isKanbanNote(readMatter(file))) {
+      reportProblems(file, "note", parseKanban(readBody(file), resolved));
+    }
+    visit(tree, "code", (node, index, parent) => {
+      if (node.lang !== resolved.language) return;
+      if (!parent || index === void 0) return;
+      reportProblems(file, "block", parseKanban(node.value, resolved));
+      const html = {
+        type: "html",
+        value: createKanbanPlaceholder(node.value)
+      };
+      parent.children.splice(index, 1, html);
+    });
+  };
+}
+function reportProblems(file, scope, result) {
+  if (result.problems.length === 0) return;
+  const reporter = file?.message;
+  if (typeof reporter !== "function") return;
+  for (const problem of result.problems) {
+    const diagnostic = reporter.call(file, `Kanban ${scope}: ${problem}`);
+    if (diagnostic && typeof diagnostic === "object") {
+      Object.assign(diagnostic, {
+        source: "@riebeckite/plugin-kanban",
+        ruleId: "kanban-parse"
+      });
+    }
+  }
+}
+function readMatter(file) {
+  return file?.data?.matter;
+}
+function readBody(file) {
+  const value = file?.value;
+  return typeof value === "string" ? stripFrontmatter(value) : "";
+}
+
+// src/render.ts
+import { escapeHtml, escapeHtmlAttribute } from "@riebeckite/core";
+var WIKILINK = /\[\[([^\]|#]+)(?:#([^\]|]+))?(?:\|([^\]]+))?\]\]/g;
+var TAG = /(^|[\s(])#([A-Za-z0-9_\-/]+)/g;
+var BOLD = /\*\*([^*]+)\*\*/g;
+function createKanbanLinkResolver(manifest) {
+  return (target) => {
+    const label = target.trim();
+    if (!label) return null;
+    const slug = manifest.contentIndex.get(label.toLowerCase());
+    if (!slug) return null;
+    const entry = manifest.bySlug.get(slug);
+    if (!entry) return null;
+    return { href: entry.permalink, label };
+  };
+}
+function renderKanban(result, options, resolveLink, source) {
+  const className = escapeHtmlAttribute(options.className);
+  const parts = [
+    `<div class="${className}" data-kanban data-kanban-plugin data-kanban-source="${source}">`,
+    `<div class="${className}__board" data-kanban-board>`
+  ];
+  for (const column of result.columns) {
+    parts.push(renderColumn(column, options, resolveLink));
+  }
+  parts.push("</div>");
+  if (options.fallback && result.fallback.length > 0) {
+    parts.push(renderFallback(result.fallback, options));
+  }
+  parts.push("</div>");
+  return parts.join("");
+}
+function renderColumn(column, options, resolveLink) {
+  const className = escapeHtmlAttribute(options.className);
+  const cards = column.cards.map((card) => renderCard(card, options, resolveLink)).join("");
+  return [
+    `<div class="${className}__column" data-column="${escapeHtmlAttribute(column.name)}">`,
+    `<header class="${className}__column-title">${escapeHtml(column.name)}</header>`,
+    `<ul class="${className}__cards">${cards}</ul>`,
+    "</div>"
+  ].join("");
+}
+function renderCard(card, options, resolveLink) {
+  const className = escapeHtmlAttribute(options.className);
+  const checked = card.checked ? "true" : "false";
+  return [
+    `<li class="${className}__card" data-checked="${checked}">`,
+    `<span class="${className}__checkbox" data-checked="${checked}" aria-hidden="true"></span>`,
+    `<span class="${className}__card-text">${renderCardText(card.text, options, resolveLink)}</span>`,
+    "</li>"
+  ].join("");
+}
+function renderCardText(text, options, resolveLink) {
+  const className = escapeHtmlAttribute(options.className);
+  let html = escapeHtml(text);
+  html = html.replace(
+    BOLD,
+    (_match, content) => `<strong class="${className}__strong">${content}</strong>`
+  );
+  html = html.replace(
+    TAG,
+    (_match, prefix, tag) => `${prefix}<span class="${className}__tag">#${tag}</span>`
+  );
+  html = html.replace(WIKILINK, (_match, target, fragment, alias) => {
+    const label = (alias ?? target).trim();
+    const link = resolveLink(target);
+    if (!link) {
+      return `<span class="${className}__wikilink ${className}__wikilink--broken">${escapeHtml(label)}</span>`;
+    }
+    const anchor = fragment ? `#${fragment}` : "";
+    return `<a class="${className}__wikilink" href="${escapeHtmlAttribute(`${link.href}${anchor}`)}" data-kanban-link="${escapeHtmlAttribute(target.trim())}">${escapeHtml(label)}</a>`;
+  });
+  return html;
+}
+function renderFallback(lines, options) {
+  const className = escapeHtmlAttribute(options.className);
+  return [
+    `<details class="${className}__fallback">`,
+    `<summary class="${className}__fallback-title">Unsupported content</summary>`,
+    `<pre class="${className}__fallback-body">${escapeHtml(lines.join("\n"))}</pre>`,
+    "</details>"
+  ].join("");
+}
+
+// src/runtime.ts
+function createKanbanRuntime(options) {
+  const markdownBySlug = /* @__PURE__ */ new Map();
+  const contentBySlug = /* @__PURE__ */ new Map();
+  return {
+    track(slug, markdown, content) {
+      markdownBySlug.set(slug, markdown);
+      contentBySlug.set(slug, content);
+    },
+    resolve(manifest) {
+      const resolveLink = createKanbanLinkResolver(manifest);
+      for (const entry of manifest.entries) {
+        const markdown = markdownBySlug.get(entry.slug);
+        if (options.autoDetect && markdown !== void 0 && isKanbanNote(entry.frontmatter)) {
+          const parsed = parseKanban(stripFrontmatter(markdown), options);
+          applyHtml(entry, contentBySlug, resolveLink, options, "note", parsed);
+          continue;
+        }
+        if (!entry.html.includes(KANBAN_ATTRIBUTE)) continue;
+        const html = replacePlaceholders(entry, options, resolveLink);
+        if (html !== entry.html) {
+          entry.html = html;
+          const content = contentBySlug.get(entry.slug);
+          if (content) content.html = html;
+        }
+      }
+    }
+  };
+}
+function applyHtml(entry, contentBySlug, resolveLink, options, source, parsed) {
+  const html = renderKanban(parsed, options, resolveLink, source);
+  if (html === entry.html) return;
+  entry.html = html;
+  const content = contentBySlug.get(entry.slug);
+  if (content) content.html = html;
+}
+function replacePlaceholders(entry, options, resolveLink) {
+  const pattern = createKanbanPlaceholderPattern();
+  return entry.html.replace(pattern, (_match, encoded) => {
+    const parsed = parseKanban(decodeKanbanSource(encoded), options);
+    return renderKanban(parsed, options, resolveLink, "block");
+  });
+}
+
+// index.ts
+function kanban(options = {}) {
+  const resolved = resolveKanbanOptions(options);
+  const runtime = createKanbanRuntime(resolved);
+  return definePlugin({
+    name: "kanban",
+    options,
+    validateOptions: validateKanbanOptions,
+    extendMarkdownPipeline: (pipeline) => {
+      pipeline.use(remarkKanban, resolved);
+    },
+    onPostProcessed: (context) => {
+      runtime.track(context.slug, context.markdown, context.content);
+    },
+    onManifestCreated: (context) => {
+      runtime.resolve(context.manifest);
+    },
+    assets: [createStyleAsset("kanban")]
+  });
+}
+var kanbanPlugin = kanban;
+function validateKanbanOptions(options) {
+  if (!options) return [];
+  const issues = [];
+  for (const key of ["className", "language", "columnMarker"]) {
+    const value = options[key];
+    if (value !== void 0 && (typeof value !== "string" || value.trim() === "")) {
+      issues.push({ path: key, message: "Expected a non-empty string." });
+    }
+  }
+  for (const key of ["autoDetect", "fallback"]) {
+    if (options[key] !== void 0 && typeof options[key] !== "boolean") {
+      issues.push({ path: key, message: "Expected a boolean." });
+    }
+  }
+  return issues;
+}
+export {
+  KANBAN_ATTRIBUTE,
+  createKanbanLinkResolver,
+  createKanbanPlaceholder,
+  createKanbanPlaceholderPattern,
+  decodeKanbanSource,
+  encodeKanbanSource,
+  isKanbanNote,
+  kanban,
+  kanbanPlugin,
+  parseKanban,
+  remarkKanban,
+  renderKanban,
+  resolveKanbanOptions,
+  stripFrontmatter
+};

package/dist/src/parse.d.ts

@@ -0,0 +1,17 @@
+import type { ResolvedKanbanOptions } from "./types.js";
+export type KanbanCard = {
+    checked: boolean;
+    text: string;
+};
+export type KanbanColumn = {
+    name: string;
+    cards: KanbanCard[];
+};
+export type KanbanParseResult = {
+    columns: KanbanColumn[];
+    fallback: string[];
+    problems: string[];
+};
+export declare function parseKanban(source: string, options: ResolvedKanbanOptions): KanbanParseResult;
+export declare function isKanbanNote(frontmatter: unknown): boolean;
+export declare function stripFrontmatter(markdown: string): string;

package/dist/src/placeholder.d.ts

@@ -0,0 +1,5 @@
+export declare const KANBAN_ATTRIBUTE = "data-rr-kanban";
+export declare function encodeKanbanSource(source: string): string;
+export declare function decodeKanbanSource(encoded: string): string;
+export declare function createKanbanPlaceholder(source: string): string;
+export declare function createKanbanPlaceholderPattern(): RegExp;

package/dist/src/remark.d.ts

@@ -0,0 +1,4 @@
+import type { Root } from "mdast";
+import { type KanbanOptions } from "./types.js";
+export type RemarkKanbanOptions = KanbanOptions;
+export declare function remarkKanban(options?: KanbanOptions): (tree: Root, file?: unknown) => void;

package/dist/src/render.d.ts

@@ -0,0 +1,11 @@
+import type { ContentManifest } from "@riebeckite/core";
+import type { KanbanParseResult } from "./parse.js";
+import type { ResolvedKanbanOptions } from "./types.js";
+export type KanbanLink = {
+    href: string;
+    label: string;
+};
+export type KanbanLinkResolver = (target: string) => KanbanLink | null;
+export type KanbanSource = "block" | "note";
+export declare function createKanbanLinkResolver(manifest: ContentManifest): KanbanLinkResolver;
+export declare function renderKanban(result: KanbanParseResult, options: ResolvedKanbanOptions, resolveLink: KanbanLinkResolver, source: KanbanSource): string;

package/dist/src/runtime.d.ts

@@ -0,0 +1,7 @@
+import type { ContentManifest, PostContent } from "@riebeckite/core";
+import type { ResolvedKanbanOptions } from "./types.js";
+export type KanbanRuntime = {
+    track(slug: string, markdown: string, content: PostContent): void;
+    resolve(manifest: ContentManifest): void;
+};
+export declare function createKanbanRuntime(options: ResolvedKanbanOptions): KanbanRuntime;

package/dist/src/types.d.ts

@@ -0,0 +1,15 @@
+export type KanbanOptions = {
+    className?: string;
+    language?: string;
+    columnMarker?: string;
+    autoDetect?: boolean;
+    fallback?: boolean;
+};
+export type ResolvedKanbanOptions = {
+    className: string;
+    language: string;
+    columnMarker: string;
+    autoDetect: boolean;
+    fallback: boolean;
+};
+export declare function resolveKanbanOptions(options?: KanbanOptions): ResolvedKanbanOptions;

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@riebeckite/plugin-kanban",
+  "version": "0.0.1",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "source": "./index.ts",
+      "default": "./dist/index.js"
+    },
+    "./style.css": "./style.css"
+  },
+  "dependencies": {
+    "@types/mdast": "^4.0.4",
+    "unist-util-visit": "^5.1.0",
+    "@riebeckite/core": "0.0.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "README_ja.md",
+    "dist",
+    "style.css"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Rerurate514/riebeckite.git",
+    "directory": "packages/plugins/kanban"
+  },
+  "homepage": "https://github.com/Rerurate514/riebeckite#readme",
+  "bugs": {
+    "url": "https://github.com/Rerurate514/riebeckite/issues"
+  },
+  "description": "Build-time rendering for Obsidian Kanban boards.",
+  "keywords": [
+    "riebeckite",
+    "plugin",
+    "kanban",
+    "obsidian"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "sideEffects": [
+    "./style.css"
+  ],
+  "scripts": {
+    "build": "node ../../../scripts/build_package.mjs"
+  }
+}

package/style.css

@@ -0,0 +1,144 @@
+.rb-kanban {
+  --rb-kanban-ink: var(--rb-color-ink, #000000);
+  --rb-kanban-paper: var(--rb-color-paper, #ffffff);
+  --rb-kanban-muted: var(--rb-color-muted, #69645c);
+  --rb-kanban-accent: var(--rb-color-accent, #686868);
+  --rb-kanban-rule: var(
+    --rb-color-border,
+    color-mix(in srgb, var(--rb-kanban-ink) 18%, transparent)
+  );
+  --rb-kanban-surface: color-mix(
+    in srgb,
+    var(--rb-kanban-paper) 94%,
+    var(--rb-kanban-ink)
+  );
+
+  margin: 1.5rem 0;
+  color: var(--rb-kanban-ink);
+}
+
+.rb-kanban__board {
+  display: flex;
+  gap: 1rem;
+  align-items: flex-start;
+  overflow-x: auto;
+  padding-bottom: 0.5rem;
+  scroll-snap-type: x proximity;
+}
+
+.rb-kanban__column {
+  flex: 0 0 16rem;
+  min-width: 16rem;
+  max-width: 20rem;
+  scroll-snap-align: start;
+  border: 1px solid var(--rb-kanban-rule);
+  background: var(--rb-kanban-surface);
+}
+
+.rb-kanban__column-title {
+  margin: 0;
+  padding: 0.5rem 0.75rem;
+  border-bottom: 1px solid var(--rb-kanban-rule);
+  font-size: 0.875rem;
+  font-weight: 700;
+  letter-spacing: 0.01em;
+}
+
+.rb-kanban__cards {
+  margin: 0;
+  padding: 0.5rem;
+  list-style: none;
+  display: flex;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+
+.rb-kanban__card {
+  display: flex;
+  gap: 0.5rem;
+  align-items: baseline;
+  padding: 0.5rem 0.625rem;
+  border: 1px solid var(--rb-kanban-rule);
+  background: var(--rb-kanban-paper);
+  font-size: 0.875rem;
+  line-height: 1.4;
+}
+
+.rb-kanban__card-text {
+  flex: 1 1 auto;
+  min-width: 0;
+  overflow-wrap: anywhere;
+}
+
+.rb-kanban__checkbox {
+  flex: 0 0 auto;
+  width: 0.75rem;
+  height: 0.75rem;
+  margin-top: 0.2em;
+  border: 1px solid var(--rb-kanban-ink);
+  transform: translateY(0.05em);
+}
+
+.rb-kanban__card[data-checked="true"] .rb-kanban__checkbox {
+  background: var(--rb-kanban-accent);
+  border-color: var(--rb-kanban-accent);
+}
+
+.rb-kanban__card[data-checked="true"] .rb-kanban__card-text {
+  color: var(--rb-kanban-muted);
+  text-decoration: line-through;
+  text-decoration-color: var(--rb-kanban-rule);
+}
+
+.rb-kanban__strong {
+  font-weight: 700;
+}
+
+.rb-kanban__tag {
+  color: var(--rb-kanban-muted);
+  font-size: 0.8125em;
+  white-space: nowrap;
+}
+
+.rb-kanban__wikilink {
+  color: inherit;
+  text-decoration: underline;
+  text-decoration-color: var(--rb-kanban-rule);
+  text-underline-offset: 0.2em;
+}
+
+.rb-kanban__wikilink:hover,
+.rb-kanban__wikilink:focus-visible {
+  text-decoration-color: var(--rb-kanban-accent);
+}
+
+.rb-kanban__wikilink--broken {
+  color: var(--rb-kanban-muted);
+  text-decoration: line-through;
+}
+
+.rb-kanban__fallback {
+  margin-top: 0.75rem;
+  font-size: 0.8125rem;
+  color: var(--rb-kanban-muted);
+}
+
+.rb-kanban__fallback-title {
+  cursor: pointer;
+}
+
+.rb-kanban__fallback-body {
+  margin: 0.5rem 0 0;
+  padding: 0.5rem 0.75rem;
+  overflow-x: auto;
+  border: 1px solid var(--rb-kanban-rule);
+  background: var(--rb-kanban-surface);
+  font-size: 0.75rem;
+  white-space: pre-wrap;
+}
+
+html[data-theme="dark"] .rb-kanban,
+html.dark .rb-kanban {
+  --rb-kanban-ink: var(--rb-color-paper, #ffffff);
+  --rb-kanban-paper: var(--rb-color-ink, #000000);
+}