@riebeckite/plugin-bases 0.0.1

package/dist/index.js

@@ -0,0 +1,909 @@
+// index.ts
+import {
+  createStyleAsset,
+  definePlugin
+} from "@riebeckite/core";
+
+// src/remark.ts
+import { visit } from "unist-util-visit";
+import { matter } from "vfile-matter";
+
+// src/parse.ts
+var DEFAULT_COLUMNS = ["file.name", "file.tags"];
+var ok = (value) => ({ ok: true, value });
+var fail = (message) => ({ ok: false, message });
+var BUILTIN_ALIASES = {
+  "file.name": "file.name",
+  "file.path": "file.path",
+  "file.slug": "file.slug",
+  "file.folder": "file.folder",
+  "file.title": "file.title",
+  "file.link": "file.link",
+  "file.permalink": "file.permalink",
+  "file.url": "file.link",
+  "file.tags": "file.tags",
+  "file.mtime": "date",
+  "file.ctime": "date",
+  "file.date": "date"
+};
+function parseBases(document) {
+  if (document === null || document === void 0) {
+    return ok({ properties: {}, views: [] });
+  }
+  if (typeof document !== "object" || Array.isArray(document)) {
+    return fail("Base definition must be a YAML mapping.");
+  }
+  const root = document;
+  const filter = parseFilters(root.filters, "filters");
+  if (filter.ok === false) return filter;
+  const properties = parseProperties(root.properties);
+  if (properties.ok === false) return properties;
+  const views = parseViews(root.views, properties.value);
+  if (views.ok === false) return views;
+  return ok({
+    ...filter.value === void 0 ? {} : { filter: filter.value },
+    properties: properties.value,
+    views: views.value
+  });
+}
+function parseFilters(value, path) {
+  if (value === void 0 || value === null) return ok(void 0);
+  if (typeof value === "string") {
+    const text = value.trim();
+    return text === "" ? ok(void 0) : parseExpression(text, path);
+  }
+  if (Array.isArray(value)) {
+    return combineAnd(value, path);
+  }
+  if (typeof value === "object") {
+    return parseFilterObject(value, path);
+  }
+  return fail(`${path} must be an expression, a list, or a filter object.`);
+}
+function parseFilterObject(object, path) {
+  const children = [];
+  if ("and" in object || "or" in object || "not" in object) {
+    if ("and" in object) {
+      const parsed = combineAnd(
+        toList(object.and),
+        `${path}.and`
+      );
+      if (parsed.ok === false) return parsed;
+      if (parsed.value) children.push(parsed.value);
+    }
+    if ("or" in object) {
+      const parsed = combineOr(toList(object.or), `${path}.or`);
+      if (parsed.ok === false) return parsed;
+      if (parsed.value) children.push(parsed.value);
+    }
+    if ("not" in object) {
+      const parsed = combineAnd(toList(object.not), `${path}.not`);
+      if (parsed.ok === false) return parsed;
+      if (parsed.value) {
+        children.push({ kind: "not", condition: parsed.value });
+      }
+    }
+    return combineAndNodes(children);
+  }
+  for (const [key, raw] of Object.entries(object)) {
+    const parsed = propertyEquality(key, raw, `${path}.${key}`);
+    if (parsed.ok === false) return parsed;
+    children.push(parsed.value);
+  }
+  return combineAndNodes(children);
+}
+function propertyEquality(key, value, path) {
+  const ref = parseValueRef(key);
+  if (Array.isArray(value)) {
+    const conditions = value.map((item) => ({
+      kind: "compare",
+      left: ref,
+      operator: "==",
+      right: scalarLiteral(item)
+    }));
+    return conditions.length === 0 ? fail(`${path} must not be an empty list.`) : ok({ kind: "or", conditions });
+  }
+  return ok({
+    kind: "compare",
+    left: ref,
+    operator: "==",
+    right: scalarLiteral(value)
+  });
+}
+function combineAnd(values, path) {
+  const children = [];
+  for (let index = 0; index < values.length; index += 1) {
+    const parsed = parseFilters(values[index], `${path}[${index}]`);
+    if (parsed.ok === false) return parsed;
+    if (parsed.value) children.push(parsed.value);
+  }
+  return combineAndNodes(children);
+}
+function combineOr(values, path) {
+  const children = [];
+  for (let index = 0; index < values.length; index += 1) {
+    const parsed = parseFilters(values[index], `${path}[${index}]`);
+    if (parsed.ok === false) return parsed;
+    if (parsed.value) children.push(parsed.value);
+  }
+  if (children.length === 0) return ok(void 0);
+  if (children.length === 1) return ok(children[0]);
+  return ok({ kind: "or", conditions: children });
+}
+function combineAndNodes(children) {
+  if (children.length === 0) return ok(void 0);
+  if (children.length === 1) return ok(children[0]);
+  return ok({ kind: "and", conditions: [...children] });
+}
+function toList(value) {
+  if (value === void 0 || value === null) return [];
+  return Array.isArray(value) ? value : [value];
+}
+function parseExpression(raw, path) {
+  let text = raw.trim();
+  while (text.startsWith("(") && text.endsWith(")") && isBalanced(text.slice(1, -1))) {
+    text = text.slice(1, -1).trim();
+  }
+  if (text === "") return fail(`${path} contains an empty filter expression.`);
+  const call = text.match(/^(?:file|note)\.(\w+)\s*\(\s*(.*?)\s*\)$/i);
+  if (call) {
+    const name = call[1].toLowerCase();
+    const argument = stripQuotes(call[2]);
+    if (argument === "") {
+      return fail(`${path} has a ${name}() call without an argument.`);
+    }
+    if (name === "hastag") return ok({ kind: "hasTag", tag: argument });
+    if (name === "infolder") return ok({ kind: "inFolder", folder: argument });
+    if (name === "haslink") return ok({ kind: "hasLink", link: argument });
+    return fail(`${path} uses an unsupported function \`${name}()\`.`);
+  }
+  if (/^[a-z_][\w.]*\s*\(/i.test(text)) {
+    return fail(`${path} uses an unsupported function in \`${text}\`.`);
+  }
+  const contains = text.match(/^(.+?)\s+contains\s+(.+)$/i);
+  if (contains) {
+    return comparisonFrom(contains[1], "contains", contains[2], path);
+  }
+  const comparison = text.match(/^(.+?)\s*(==|!=|>=|<=|>|<)\s*(.+)$/);
+  if (comparison) {
+    return comparisonFrom(
+      comparison[1],
+      comparison[2],
+      comparison[3],
+      path
+    );
+  }
+  return fail(`${path} uses an unsupported filter expression \`${raw}\`.`);
+}
+function comparisonFrom(left, operator, right, path) {
+  const reference = left.trim();
+  if (reference === "") {
+    return fail(`${path} is missing a left-hand side for \`${operator}\`.`);
+  }
+  return ok({
+    kind: "compare",
+    left: parseValueRef(reference),
+    operator,
+    right: parseLiteral(right)
+  });
+}
+function parseValueRef(raw) {
+  const key = stripQuotes(raw.trim());
+  const lower = key.toLowerCase();
+  const alias = BUILTIN_ALIASES[lower];
+  if (alias !== void 0) {
+    if (alias === "date") return { source: "frontmatter", key: "date" };
+    return { source: "builtin", name: alias };
+  }
+  if (lower.startsWith("note.")) {
+    return { source: "frontmatter", key: key.slice("note.".length) };
+  }
+  if (lower.startsWith("file.frontmatter.")) {
+    return {
+      source: "frontmatter",
+      key: key.slice("file.frontmatter.".length)
+    };
+  }
+  if (lower.startsWith("file.")) {
+    return { source: "frontmatter", key: key.slice("file.".length) };
+  }
+  return { source: "frontmatter", key };
+}
+function parseLiteral(raw) {
+  const text = raw.trim();
+  if (isQuoted(text)) return stripQuotes(text);
+  if (text === "true") return true;
+  if (text === "false") return false;
+  if (text === "null" || text === "~") return null;
+  if (/^-?\d+(\.\d+)?$/.test(text)) return Number(text);
+  return text;
+}
+function scalarLiteral(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") return value;
+  return String(value);
+}
+function isQuoted(value) {
+  if (value.length < 2) return false;
+  const first = value[0];
+  const last = value[value.length - 1];
+  return first === '"' && last === '"' || first === "'" && last === "'";
+}
+function stripQuotes(value) {
+  const text = value.trim();
+  return isQuoted(text) ? text.slice(1, -1) : text;
+}
+function isBalanced(value) {
+  let depth = 0;
+  for (const char of value) {
+    if (char === "(") depth += 1;
+    else if (char === ")") {
+      depth -= 1;
+      if (depth < 0) return false;
+    }
+  }
+  return depth === 0;
+}
+function parseProperties(value) {
+  if (value === void 0 || value === null) return ok({});
+  if (typeof value !== "object" || Array.isArray(value)) {
+    return fail("`properties` must be a YAML mapping.");
+  }
+  const labels = {};
+  for (const [key, raw] of Object.entries(value)) {
+    labels[key] = propertyLabel(key, raw);
+  }
+  return ok(labels);
+}
+function propertyLabel(key, raw) {
+  if (typeof raw === "string" && raw.trim() !== "") return raw;
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    const displayName = raw.displayName;
+    if (typeof displayName === "string" && displayName.trim() !== "") {
+      return displayName;
+    }
+  }
+  return key;
+}
+function parseViews(value, properties) {
+  if (value === void 0 || value === null) return ok([]);
+  if (!Array.isArray(value)) return fail("`views` must be a list.");
+  const views = [];
+  for (let index = 0; index < value.length; index += 1) {
+    const parsed = parseView(value[index], properties, `views[${index}]`);
+    if (parsed.ok === false) return parsed;
+    views.push(parsed.value);
+  }
+  return ok(views);
+}
+function parseView(value, properties, path) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return fail(`${path} must be a mapping.`);
+  }
+  const object = value;
+  const type = parseViewType(object.type, path);
+  if (type.ok === false) return type;
+  const filter = parseFilters(object.filters, `${path}.filters`);
+  if (filter.ok === false) return filter;
+  const columns = parseColumns(object, properties);
+  const sort = parseSort(object.sort, `${path}.sort`);
+  if (sort.ok === false) return sort;
+  const limit = parseLimit(object.limit, `${path}.limit`);
+  if (limit.ok === false) return limit;
+  const name = typeof object.name === "string" && object.name.trim() !== "" ? object.name : void 0;
+  return ok({
+    type: type.value,
+    ...name === void 0 ? {} : { name },
+    columns,
+    ...filter.value === void 0 ? {} : { filter: filter.value },
+    ...sort.value === void 0 ? {} : { sort: sort.value },
+    ...limit.value === void 0 ? {} : { limit: limit.value }
+  });
+}
+function parseViewType(value, path) {
+  if (value === void 0 || value === null) return ok("table");
+  const text = String(value).trim().toLowerCase();
+  if (text === "table" || text === "cards") return ok(text);
+  return fail(`${path}.type must be "table" or "cards".`);
+}
+function parseColumns(object, properties) {
+  const configured = readStringList(object.order) ?? readStringList(object.columns);
+  if (configured && configured.length > 0) return configured;
+  const fromProperties = Object.keys(properties);
+  if (fromProperties.length > 0) return fromProperties;
+  return [...DEFAULT_COLUMNS];
+}
+function readStringList(value) {
+  if (value === void 0 || value === null) return null;
+  const list = Array.isArray(value) ? value : [value];
+  const out = list.filter((item) => {
+    return typeof item === "string" || typeof item === "number";
+  }).map((item) => String(item).trim()).filter((item) => item !== "");
+  return out;
+}
+function parseSort(value, path) {
+  if (value === void 0 || value === null) return ok(void 0);
+  const list = Array.isArray(value) ? value : [value];
+  const sorts = [];
+  for (let index = 0; index < list.length; index += 1) {
+    const entry = list[index];
+    if (typeof entry === "string") {
+      const text = entry.trim();
+      if (text === "") continue;
+      const descending = text.startsWith("-");
+      sorts.push({
+        field: mapSortField(descending ? text.slice(1) : text),
+        order: descending ? "desc" : "asc"
+      });
+      continue;
+    }
+    if (entry && typeof entry === "object" && !Array.isArray(entry)) {
+      const record = entry;
+      const property = record.property ?? record.field;
+      if (typeof property !== "string" || property.trim() === "") {
+        return fail(`${path}[${index}] must name a \`property\` or \`field\`.`);
+      }
+      const direction = record.direction ?? record.order;
+      const descending = typeof direction === "string" && direction.trim().toLowerCase() === "desc";
+      sorts.push({
+        field: mapSortField(property),
+        order: descending ? "desc" : "asc"
+      });
+      continue;
+    }
+    return fail(`${path}[${index}] must be a property name or a mapping.`);
+  }
+  return ok(sorts.length === 0 ? void 0 : sorts);
+}
+function mapSortField(property) {
+  const ref = parseValueRef(property);
+  if (ref.source === "frontmatter") return ref.key;
+  switch (ref.name) {
+    case "file.name":
+    case "file.title":
+      return "title";
+    case "file.path":
+    case "file.slug":
+      return "slug";
+    case "file.link":
+    case "file.permalink":
+      return "permalink";
+    case "file.tags":
+      return "tags";
+    case "file.folder":
+      return "slug";
+    default:
+      return property;
+  }
+}
+function parseLimit(value, path) {
+  if (value === void 0 || value === null) return ok(void 0);
+  if (typeof value !== "number" || !Number.isFinite(value) || value < 0) {
+    return fail(`${path} must be a non-negative number.`);
+  }
+  return ok(Math.floor(value));
+}
+
+// src/placeholder.ts
+var BASES_ATTRIBUTE = "data-rr-bases";
+function encodeBasesPayload(payload) {
+  return encodeURIComponent(JSON.stringify(payload));
+}
+function decodeBasesPayload(encoded) {
+  try {
+    const parsed = JSON.parse(decodeURIComponent(encoded));
+    if (!parsed || typeof parsed !== "object") return null;
+    const candidate = parsed;
+    if (typeof candidate.source !== "string" || !candidate.spec) return null;
+    return candidate;
+  } catch {
+    return null;
+  }
+}
+function createBasesPlaceholder(payload) {
+  return `<div ${BASES_ATTRIBUTE}="${encodeBasesPayload(payload)}"></div>`;
+}
+function createBasesPlaceholderPattern() {
+  return new RegExp(
+    `<div\\b[^>]*\\b${BASES_ATTRIBUTE}="([^"]*)"[^>]*>\\s*</div>`,
+    "g"
+  );
+}
+
+// src/remark.ts
+function remarkBases(options = {}) {
+  const language = options.language ?? "base";
+  return (tree, file) => {
+    visit(tree, "code", (node, index, parent) => {
+      if (node.lang !== language) return;
+      if (!parent || index === void 0) return;
+      const parsed = parseYaml(node.value);
+      if (parsed.ok === false) {
+        reportDiagnostic(file, parsed.message, node);
+        return;
+      }
+      const spec = parseBases(parsed.value);
+      if (spec.ok === false) {
+        reportDiagnostic(file, spec.message, node);
+        return;
+      }
+      const html = {
+        type: "html",
+        value: createBasesPlaceholder({ spec: spec.value, source: node.value })
+      };
+      parent.children.splice(index, 1, html);
+    });
+  };
+}
+function parseYaml(source) {
+  try {
+    const document = `---
+${source}
+---
+`;
+    const file = {
+      value: document,
+      data: {},
+      toString: () => document
+    };
+    matter(file);
+    return { ok: true, value: file.data.matter };
+  } catch (error) {
+    return {
+      ok: false,
+      message: `Base block is not valid YAML (${formatError(error)}).`
+    };
+  }
+}
+function reportDiagnostic(file, message, node) {
+  const reporter = file?.message;
+  if (typeof reporter !== "function") return;
+  const diagnostic2 = reporter.call(file, message, node);
+  if (diagnostic2 && typeof diagnostic2 === "object") {
+    Object.assign(diagnostic2, { source: "@riebeckite/plugin-bases" });
+  }
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/runtime.ts
+import { isPublished } from "@riebeckite/core";
+
+// src/render.ts
+import {
+  escapeHtml,
+  escapeHtmlAttribute,
+  queryContentEntries
+} from "@riebeckite/core";
+
+// src/evaluate.ts
+function matchesCondition(condition, entry) {
+  switch (condition.kind) {
+    case "and":
+      return condition.conditions.every(
+        (child) => matchesCondition(child, entry)
+      );
+    case "or":
+      return condition.conditions.some(
+        (child) => matchesCondition(child, entry)
+      );
+    case "not":
+      return !matchesCondition(condition.condition, entry);
+    case "hasTag":
+      return hasTag(entry.tags, condition.tag);
+    case "inFolder":
+      return inFolder(entry.slug, condition.folder);
+    case "hasLink":
+      return hasLink(entry.links, condition.link);
+    case "compare":
+      return compare(
+        resolveValueRef(condition.left, entry),
+        condition.operator,
+        condition.right
+      );
+    default:
+      return false;
+  }
+}
+function resolveValueRef(reference, entry) {
+  if (reference.source === "frontmatter") {
+    return entry.frontmatter[reference.key];
+  }
+  return resolveBuiltin(reference.name, entry);
+}
+function resolveBuiltin(name, entry) {
+  switch (name) {
+    case "file.name":
+      return entry.title;
+    case "file.path":
+    case "file.slug":
+      return entry.slug;
+    case "file.folder":
+      return folderOf(entry.slug);
+    case "file.title":
+      return entry.title;
+    case "file.link":
+    case "file.permalink":
+      return entry.permalink;
+    case "file.tags":
+      return entry.tags;
+    default:
+      return void 0;
+  }
+}
+function hasTag(tags, tag) {
+  const target = tag.trim().replace(/^#/, "").toLowerCase();
+  if (target === "") return false;
+  return tags.some((value) => {
+    const normalized = value.toLowerCase();
+    return normalized === target || normalized.startsWith(`${target}/`);
+  });
+}
+function inFolder(slug, folder) {
+  const target = folder.trim().replace(/^\/+|\/+$/g, "");
+  if (target === "") return true;
+  return slug === target || slug.startsWith(`${target}/`);
+}
+function hasLink(links, link) {
+  const target = normalizeLink(link);
+  if (target === "") return false;
+  return links.some((candidate) => {
+    if (candidate.slug !== null && candidate.slug.toLowerCase() === target) {
+      return true;
+    }
+    const raw = normalizeLink(candidate.raw);
+    return raw === target || baseName(raw) === baseName(target);
+  });
+}
+function normalizeLink(value) {
+  return value.trim().replace(/^\[\[|\]\]$/g, "").split("|")[0].split("#")[0].replace(/\.md$/i, "").replace(/^\.?\//, "").toLowerCase();
+}
+function baseName(value) {
+  const parts = value.split("/");
+  return parts[parts.length - 1] ?? value;
+}
+function folderOf(slug) {
+  const index = slug.lastIndexOf("/");
+  return index === -1 ? "" : slug.slice(0, index);
+}
+function compare(actual, operator, expected) {
+  if (operator === "contains") return containsValue(actual, expected);
+  if (operator === "==" || operator === "!=") {
+    const equal = equalsAny(actual, expected);
+    return operator === "==" ? equal : !equal;
+  }
+  const order = compareOrder(actual, expected);
+  if (order === null) return false;
+  switch (operator) {
+    case ">":
+      return order > 0;
+    case "<":
+      return order < 0;
+    case ">=":
+      return order >= 0;
+    case "<=":
+      return order <= 0;
+    default:
+      return false;
+  }
+}
+function equalsAny(actual, expected) {
+  if (Array.isArray(actual)) {
+    return actual.some((item) => scalarEquals(item, expected));
+  }
+  return scalarEquals(actual, expected);
+}
+function scalarEquals(actual, expected) {
+  if (actual === void 0 || actual === null) return expected === null;
+  if (typeof actual === "string" && typeof expected === "string") {
+    return actual.toLowerCase() === expected.toLowerCase();
+  }
+  if (actual instanceof Date) {
+    const time = toComparableNumber(expected);
+    return time !== null && actual.getTime() === time;
+  }
+  return actual === expected;
+}
+function containsValue(actual, expected) {
+  if (Array.isArray(actual)) {
+    return actual.some(
+      (item) => typeof item === "string" && typeof expected === "string" ? item.toLowerCase().includes(expected.toLowerCase()) : scalarEquals(item, expected)
+    );
+  }
+  if (typeof actual === "string") {
+    return actual.toLowerCase().includes(String(expected ?? "").toLowerCase());
+  }
+  return false;
+}
+function compareOrder(actual, expected) {
+  if (actual === void 0 || actual === null) return null;
+  const left = toComparableNumber(actual);
+  const right = toComparableNumber(expected);
+  if (left !== null && right !== null) {
+    return Math.sign(left - right);
+  }
+  if (actual instanceof Date) return null;
+  return Math.sign(String(actual).localeCompare(String(expected ?? ""), "en"));
+}
+function toComparableNumber(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : null;
+  }
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (value instanceof Date) {
+    const time = value.getTime();
+    return Number.isFinite(time) ? time : null;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (trimmed === "") return null;
+    if (/^-?\d+(\.\d+)?$/.test(trimmed)) return Number(trimmed);
+    const time = Date.parse(trimmed);
+    if (!Number.isNaN(time)) return time;
+  }
+  return null;
+}
+
+// src/render.ts
+var TITLE_PROPERTIES = /* @__PURE__ */ new Set(["file.name", "file.title", "title", "name"]);
+var LINK_PROPERTIES = /* @__PURE__ */ new Set([
+  "file.link",
+  "file.permalink",
+  "file.url",
+  "permalink",
+  "url"
+]);
+var TAG_PROPERTIES = /* @__PURE__ */ new Set(["file.tags", "tags"]);
+var BUILTIN_LABELS = {
+  "file.name": "Name",
+  "file.path": "Path",
+  "file.slug": "Slug",
+  "file.folder": "Folder",
+  "file.title": "Title",
+  "file.link": "Link",
+  "file.permalink": "Permalink",
+  "file.tags": "Tags"
+};
+var DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+function renderBases(spec, options, entries, source) {
+  const className = options.className ?? "rb-bases";
+  const views = selectViews(spec, options.view);
+  const limit = resolveLimit(options.limit);
+  const sections = views.map((view) => renderView(view, spec, className, entries, limit)).join("");
+  const fallback = options.showFallback === false ? "" : renderFallback(className, source);
+  const firstType = views[0]?.type ?? "table";
+  return `<div class="${escapeHtmlAttribute(className)}" data-bases data-bases-view="${firstType}">${sections}${fallback}</div>`;
+}
+function renderBasesError(message, options) {
+  const className = options.className ?? "rb-bases";
+  return `<div class="${escapeHtmlAttribute(className)} ${escapeHtmlAttribute(className)}--error" role="status">${escapeHtml(message)}</div>`;
+}
+function selectViews(spec, requested) {
+  const configured = spec.views;
+  if (requested && requested.trim() !== "") {
+    const target = requested.trim().toLowerCase();
+    const matches = configured.filter(
+      (view) => view.name?.toLowerCase() === target
+    );
+    if (matches.length > 0) return matches;
+  }
+  if (configured.length > 0) return [...configured];
+  const properties = Object.keys(spec.properties);
+  return [
+    {
+      type: "table",
+      columns: properties.length > 0 ? properties : [...DEFAULT_COLUMNS]
+    }
+  ];
+}
+function resolveLimit(limit) {
+  if (typeof limit === "number" && Number.isFinite(limit) && limit >= 0) {
+    return Math.floor(limit);
+  }
+  return 100;
+}
+function renderView(view, spec, className, entries, limit) {
+  const pool = entries.filter(
+    (entry) => view.filter === void 0 || matchesCondition(view.filter, entry)
+  );
+  const effectiveLimit = Math.min(view.limit ?? limit, limit);
+  const selected = queryContentEntries(pool, {
+    ...view.sort === void 0 ? {} : { sort: view.sort },
+    limit: effectiveLimit
+  });
+  const name = view.name ? `<h3 class="${escapeHtmlAttribute(className)}__view-name">${escapeHtml(view.name)}</h3>` : "";
+  const body = view.type === "cards" ? renderCards(view, selected, spec, className) : renderTable(view, selected, spec, className);
+  return `<section class="${escapeHtmlAttribute(className)}__view" data-bases-view="${view.type}">${name}${body}</section>`;
+}
+function renderTable(view, entries, spec, className) {
+  if (entries.length === 0) return renderEmpty(className);
+  const head = view.columns.map(
+    (property) => `<th class="${escapeHtmlAttribute(className)}__heading" scope="col">${escapeHtml(columnLabel(property, spec))}</th>`
+  ).join("");
+  const rows = entries.map((entry) => {
+    const cells = view.columns.map(
+      (property) => `<td class="${escapeHtmlAttribute(className)}__cell">${renderCell(entry, property, className)}</td>`
+    ).join("");
+    return `<tr class="${escapeHtmlAttribute(className)}__row">${cells}</tr>`;
+  }).join("");
+  return [
+    `<table class="${escapeHtmlAttribute(className)}__table">`,
+    `<thead><tr>${head}</tr></thead>`,
+    `<tbody>${rows}</tbody>`,
+    "</table>"
+  ].join("");
+}
+function renderCards(view, entries, spec, className) {
+  if (entries.length === 0) return renderEmpty(className);
+  const titleProperty = view.columns.find(
+    (property) => TITLE_PROPERTIES.has(property.toLowerCase())
+  );
+  const fields = view.columns.filter(
+    (property) => property !== titleProperty
+  );
+  const items = entries.map((entry) => {
+    const title = `<a class="${escapeHtmlAttribute(className)}__link" href="${escapeHtmlAttribute(entry.permalink)}">${escapeHtml(entry.title)}</a>`;
+    const fieldHtml = fields.map((property) => {
+      const label = escapeHtml(columnLabel(property, spec));
+      const value = renderCell(entry, property, className);
+      return `<div class="${escapeHtmlAttribute(className)}__field"><dt class="${escapeHtmlAttribute(className)}__field-label">${label}</dt><dd class="${escapeHtmlAttribute(className)}__field-value">${value}</dd></div>`;
+    }).join("");
+    const fieldsBlock = fieldHtml ? `<dl class="${escapeHtmlAttribute(className)}__fields">${fieldHtml}</dl>` : "";
+    return `<li class="${escapeHtmlAttribute(className)}__card"><div class="${escapeHtmlAttribute(className)}__card-title">${title}</div>${fieldsBlock}</li>`;
+  }).join("");
+  return `<ul class="${escapeHtmlAttribute(className)}__cards">${items}</ul>`;
+}
+function renderEmpty(className) {
+  return `<p class="${escapeHtmlAttribute(className)}__empty">No matching notes.</p>`;
+}
+function renderFallback(className, source) {
+  return `<details class="${escapeHtmlAttribute(className)}__fallback"><summary>Base definition</summary><pre><code>${escapeHtml(source)}</code></pre></details>`;
+}
+function renderCell(entry, property, className) {
+  const key = property.toLowerCase();
+  if (TITLE_PROPERTIES.has(key)) {
+    return `<a class="${escapeHtmlAttribute(className)}__link" href="${escapeHtmlAttribute(entry.permalink)}">${escapeHtml(entry.title)}</a>`;
+  }
+  if (LINK_PROPERTIES.has(key)) {
+    return `<a class="${escapeHtmlAttribute(className)}__link" href="${escapeHtmlAttribute(entry.permalink)}">${escapeHtml(entry.permalink)}</a>`;
+  }
+  if (TAG_PROPERTIES.has(key)) {
+    return entry.tags.length === 0 ? "" : `<span class="${escapeHtmlAttribute(className)}__tags">${entry.tags.map(
+      (tag) => `<span class="${escapeHtmlAttribute(className)}__tag">#${escapeHtml(tag)}</span>`
+    ).join(" ")}</span>`;
+  }
+  const value = resolveValueRef(parseValueRef(property), entry);
+  return escapeHtml(formatValue(value));
+}
+function columnLabel(property, spec) {
+  const configured = spec.properties[property];
+  if (configured && configured !== "") return configured;
+  const key = property.toLowerCase();
+  const builtin = BUILTIN_LABELS[key];
+  if (builtin) return builtin;
+  const normalized = property.replace(/^note\./i, "").replace(/^file\.frontmatter\./i, "");
+  return normalized;
+}
+function formatValue(value) {
+  if (value === void 0 || value === null) return "";
+  if (value instanceof Date) return formatDate(value);
+  if (Array.isArray(value)) return value.map((item) => formatValue(item)).join(", ");
+  if (typeof value === "string") {
+    return DATE_ONLY.test(value.trim()) ? value.trim() : value;
+  }
+  return String(value);
+}
+function formatDate(value) {
+  const time = value.getTime();
+  if (!Number.isFinite(time)) return "";
+  return value.toISOString().slice(0, 10);
+}
+
+// src/runtime.ts
+function createBasesRuntime(options) {
+  const tracked = /* @__PURE__ */ new Map();
+  return {
+    track(slug, content) {
+      tracked.set(slug, content);
+    },
+    resolve(manifest, diagnostics, config) {
+      const entries = config ? manifest.entries.filter(
+        (entry) => isPublished(config, entry.frontmatter)
+      ) : manifest.entries;
+      for (const entry of entries) {
+        if (!entry.html.includes(BASES_ATTRIBUTE)) continue;
+        const html = replacePlaceholders(entry, entries, options, diagnostics);
+        if (html === entry.html) continue;
+        entry.html = html;
+        const content = tracked.get(entry.slug);
+        if (content) content.html = html;
+      }
+    }
+  };
+}
+function replacePlaceholders(entry, entries, options, diagnostics) {
+  const pattern = createBasesPlaceholderPattern();
+  return entry.html.replace(pattern, (_match, encoded) => {
+    const payload = decodeBasesPayload(encoded);
+    if (!payload) {
+      const message = `Base block in \`${entry.slug}\` could not be decoded.`;
+      diagnostics.push(diagnostic(entry, message));
+      return renderBasesError(message, options);
+    }
+    try {
+      return renderBases(payload.spec, options, entries, payload.source);
+    } catch (error) {
+      const message = `Base block in \`${entry.slug}\` failed to render (${formatError2(error)}).`;
+      diagnostics.push(diagnostic(entry, message));
+      return renderBasesError(message, options);
+    }
+  });
+}
+function diagnostic(entry, message) {
+  return {
+    code: "bases-invalid",
+    severity: "error",
+    pluginName: "bases",
+    slug: entry.slug,
+    message
+  };
+}
+function formatError2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// index.ts
+function bases(options = {}) {
+  const language = options.language ?? "base";
+  const runtime = createBasesRuntime(options);
+  return definePlugin({
+    name: "bases",
+    options,
+    provides: ["content.bases"],
+    validateOptions: validateBasesOptions,
+    extendMarkdownPipeline: (pipeline) => {
+      pipeline.use(remarkBases, { language });
+    },
+    onPostProcessed: (context) => {
+      runtime.track(context.slug, context.content);
+    },
+    onManifestCreated: (context) => {
+      runtime.resolve(context.manifest, context.diagnostics, context.config);
+    },
+    assets: [createStyleAsset("bases")]
+  });
+}
+var basesPlugin = bases;
+function validateBasesOptions(options) {
+  if (!options) return [];
+  const issues = [];
+  if (options.className !== void 0 && (typeof options.className !== "string" || options.className.trim() === "")) {
+    issues.push({ path: "className", message: "Expected a non-empty string." });
+  }
+  if (options.language !== void 0 && (typeof options.language !== "string" || options.language.trim() === "")) {
+    issues.push({ path: "language", message: "Expected a non-empty string." });
+  }
+  if (options.limit !== void 0 && (!Number.isFinite(options.limit) || options.limit < 0)) {
+    issues.push({
+      path: "limit",
+      message: "Expected a non-negative finite number."
+    });
+  }
+  if (options.showFallback !== void 0 && typeof options.showFallback !== "boolean") {
+    issues.push({ path: "showFallback", message: "Expected a boolean." });
+  }
+  if (options.view !== void 0 && (typeof options.view !== "string" || options.view.trim() === "")) {
+    issues.push({ path: "view", message: "Expected a non-empty string." });
+  }
+  return issues;
+}
+export {
+  bases,
+  basesPlugin,
+  matchesCondition,
+  parseBases,
+  remarkBases,
+  resolveValueRef
+};