sogo-db-core 0.1.0

package/dist/index.js

@@ -0,0 +1,778 @@
+// src/types.ts
+var STATUS_GROUPS = {
+  "Not started": { label: "Not started", color: "#5e5e5e" },
+  "In progress": { label: "In progress", color: "#2e75d0" },
+  "Done": { label: "Done", color: "#2d9e6b" }
+};
+var STATUS_OPTIONS = ["Not started", "In progress", "Done"];
+var DEFAULT_OPTION_COLORS = [
+  "#6b7280",
+  "#8b6b4a",
+  "#f59e0b",
+  "#10b981",
+  "#3b82f6",
+  "#a855f7",
+  "#ef4444"
+];
+
+// src/formula.ts
+function computeFormulaValue(record, field) {
+  let expression = field.formula?.expression?.trim();
+  if (!expression) return null;
+  if (expression.startsWith("=")) expression = expression.slice(1).trim();
+  const functionMatch = /^([a-zA-Z_][a-zA-Z0-9_]*)\((.*)\)$/.exec(expression);
+  if (functionMatch) {
+    const fnName = functionMatch[1].toUpperCase();
+    const args = splitFormulaArgs(functionMatch[2]).map((arg) => evaluateFormulaToken(arg, record));
+    return applyFormulaFunction(fnName, args, record);
+  }
+  const arithmetic = tryEvaluateArithmetic(expression, record);
+  if (arithmetic !== null && arithmetic !== void 0) return arithmetic;
+  const replaced = expression.replace(/\{([^}]+)\}/g, (_full, fieldId) => {
+    const value = record[String(fieldId).trim()];
+    if (value === null || value === void 0) return "";
+    if (Array.isArray(value)) return value.join(", ");
+    return String(value);
+  });
+  const asNumber = Number(replaced);
+  return Number.isFinite(asNumber) && replaced !== "" ? asNumber : replaced;
+}
+function splitFormulaArgs(args) {
+  const out = [];
+  let current = "";
+  let depth = 0;
+  let quote = null;
+  for (let i = 0; i < args.length; i++) {
+    const ch = args[i];
+    if ((ch === '"' || ch === "'") && (!quote || quote === ch)) {
+      quote = quote ? null : ch;
+      current += ch;
+      continue;
+    }
+    if (!quote) {
+      if (ch === "(") {
+        depth++;
+        current += ch;
+        continue;
+      }
+      if (ch === ")") {
+        depth = Math.max(0, depth - 1);
+        current += ch;
+        continue;
+      }
+      if (ch === "," && depth === 0) {
+        out.push(current.trim());
+        current = "";
+        continue;
+      }
+    }
+    current += ch;
+  }
+  if (current.trim()) out.push(current.trim());
+  return out;
+}
+function evaluateFormulaToken(token, record) {
+  const t = token.trim();
+  if (!t.length) return null;
+  if (t.startsWith('"') && t.endsWith('"') || t.startsWith("'") && t.endsWith("'")) {
+    return t.slice(1, -1);
+  }
+  const num = Number(t);
+  if (Number.isFinite(num) && !/[a-zA-Z{}]/.test(t)) return num;
+  const fieldRef = /^\{([^}]+)\}$/.exec(t);
+  if (fieldRef) {
+    const value = record[fieldRef[1].trim()];
+    if (Array.isArray(value)) return value.join(", ");
+    if (value === null || value === void 0) return null;
+    return value;
+  }
+  const bool = t.toLowerCase();
+  if (bool === "true") return true;
+  if (bool === "false") return false;
+  return t;
+}
+function applyFormulaFunction(name, args, record) {
+  switch (name) {
+    case "SUM":
+      return numericArgs(args).reduce((sum, v) => sum + v, 0);
+    case "AVG": {
+      const nums = numericArgs(args);
+      return nums.length ? nums.reduce((sum, v) => sum + v, 0) / nums.length : 0;
+    }
+    case "MIN": {
+      const nums = numericArgs(args);
+      return nums.length ? Math.min(...nums) : 0;
+    }
+    case "MAX": {
+      const nums = numericArgs(args);
+      return nums.length ? Math.max(...nums) : 0;
+    }
+    case "ABS":
+      return Math.abs(Number(args[0] ?? 0));
+    case "ROUND":
+      return Math.round(Number(args[0] ?? 0));
+    case "LEN":
+      return String(args[0] ?? "").length;
+    case "UPPER":
+      return String(args[0] ?? "").toUpperCase();
+    case "LOWER":
+      return String(args[0] ?? "").toLowerCase();
+    case "CONCAT":
+      return args.map((v) => v === null || v === void 0 ? "" : String(v)).join("");
+    case "NOW":
+      return (/* @__PURE__ */ new Date()).toISOString();
+    case "TODAY":
+      return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+    case "IF": {
+      const condition = evaluateFormulaCondition(args[0], record);
+      return condition ? args[1] === null || args[1] === void 0 ? "" : args[1] : args[2] === null || args[2] === void 0 ? "" : args[2];
+    }
+    default:
+      return args[0] === null || args[0] === void 0 ? null : String(args[0]);
+  }
+}
+function evaluateFormulaCondition(raw, record) {
+  if (typeof raw === "boolean") return raw;
+  if (typeof raw === "number") return raw !== 0;
+  if (raw === null || raw === void 0) return false;
+  const condition = String(raw).trim();
+  const match = /(.+?)(>=|<=|!=|=|>|<)(.+)/.exec(condition);
+  if (!match) return Boolean(condition);
+  const left = evaluateFormulaToken(match[1].trim(), record);
+  const right = evaluateFormulaToken(match[3].trim(), record);
+  const op = match[2];
+  if (typeof left === "number" || typeof right === "number") {
+    const ln = Number(left ?? 0);
+    const rn = Number(right ?? 0);
+    switch (op) {
+      case ">":
+        return ln > rn;
+      case "<":
+        return ln < rn;
+      case ">=":
+        return ln >= rn;
+      case "<=":
+        return ln <= rn;
+      case "=":
+        return ln === rn;
+      case "!=":
+        return ln !== rn;
+      default:
+        return false;
+    }
+  }
+  const ls = String(left ?? "");
+  const rs = String(right ?? "");
+  switch (op) {
+    case "=":
+      return ls === rs;
+    case "!=":
+      return ls !== rs;
+    case ">":
+      return ls > rs;
+    case "<":
+      return ls < rs;
+    case ">=":
+      return ls >= rs;
+    case "<=":
+      return ls <= rs;
+    default:
+      return false;
+  }
+}
+function numericArgs(args) {
+  return args.map((v) => Number(v)).filter((v) => Number.isFinite(v));
+}
+function tryEvaluateArithmetic(expression, record) {
+  const replaced = expression.replace(/\{([^}]+)\}/g, (_full, fieldId) => {
+    const value = Number(record[String(fieldId).trim()]);
+    return Number.isFinite(value) ? String(value) : "0";
+  });
+  if (!/^[0-9+\-*/().\s%]+$/.test(replaced)) return null;
+  try {
+    const value = Function(`"use strict"; return (${replaced});`)();
+    return Number.isFinite(value) ? Number(value) : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/relations.ts
+function getRelationTargetDatabase(db, relationField, resolveDatabase) {
+  const targetDatabaseId = relationField.relation?.targetDatabaseId;
+  if (targetDatabaseId && resolveDatabase) {
+    return resolveDatabase(targetDatabaseId) ?? db;
+  }
+  return db;
+}
+function inferImplicitRelationTargets(db, databases) {
+  const peers = [...databases].filter((candidate) => candidate.id !== db.id);
+  let changed = false;
+  for (const field of db.schema) {
+    if (field.type !== "relation") continue;
+    field.relation ??= {};
+    if (field.relation.targetDatabaseId) continue;
+    const inferred = inferTargetDatabase(field.name, db.name, peers);
+    if (!inferred) continue;
+    field.relation.targetDatabaseId = inferred.id;
+    changed = true;
+    if (!field.relation.targetRelationFieldId) {
+      const backlink = inferBacklinkField(inferred, db.name);
+      if (backlink) field.relation.targetRelationFieldId = backlink.id;
+    }
+  }
+  return changed;
+}
+function inferTargetDatabase(relationFieldName, sourceDbName, peers) {
+  const relationToken = normalizeToken(relationFieldName);
+  const sourceToken = normalizeToken(sourceDbName);
+  const candidates = [
+    ...peers.filter((p) => normalizeToken(p.name) === relationToken),
+    ...peers.filter((p) => normalizeToken(p.name).includes(relationToken)),
+    ...peers.filter((p) => relationToken.includes(normalizeToken(p.name)))
+  ];
+  if (candidates.length) return candidates[0];
+  if (relationToken.includes("project")) {
+    return peers.find((p) => normalizeToken(p.name).includes("project"));
+  }
+  if (sourceToken.includes("task") && relationToken.includes("project")) {
+    return peers.find((p) => normalizeToken(p.name).includes("project"));
+  }
+  if (sourceToken.includes("project") && relationToken.includes("task")) {
+    return peers.find((p) => normalizeToken(p.name).includes("task"));
+  }
+  return void 0;
+}
+function inferBacklinkField(targetDb, sourceDbName) {
+  const sourceToken = normalizeToken(sourceDbName);
+  return targetDb.schema.find(
+    (field) => field.type === "relation" && normalizeToken(field.name).includes(sourceToken)
+  );
+}
+function normalizeToken(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "").replace(/s$/, "");
+}
+
+// src/rollup.ts
+function computeRollupValue(record, field, db, resolveDatabase) {
+  const rollup = field.rollup;
+  if (!rollup) return null;
+  const relationField = db.schema.find((f) => f.id === rollup.relationFieldId && f.type === "relation");
+  if (!relationField) return null;
+  const targetDb = getRelationTargetDatabase(db, relationField, resolveDatabase);
+  const rawLinked = record[relationField.id];
+  const linkedIds = Array.isArray(rawLinked) ? rawLinked.map((id) => String(id)) : [];
+  if (!linkedIds.length) {
+    return rollup.aggregation === "count" ? 0 : null;
+  }
+  const linkedRecords = targetDb.records.filter((r) => linkedIds.includes(r.id));
+  if (!linkedRecords.length) {
+    return rollup.aggregation === "count" ? 0 : null;
+  }
+  if (rollup.aggregation === "count") return linkedRecords.length;
+  if (rollup.aggregation === "count_not_empty") {
+    const target = rollup.targetFieldId;
+    if (!target) return 0;
+    return linkedRecords.filter((r) => {
+      const value = r[target];
+      return value !== null && value !== void 0 && value !== "" && !(Array.isArray(value) && value.length === 0);
+    }).length;
+  }
+  const targetFieldId = rollup.targetFieldId;
+  if (!targetFieldId) return null;
+  const nums = linkedRecords.map((r) => Number(r[targetFieldId])).filter((v) => Number.isFinite(v));
+  if (!nums.length) return null;
+  switch (rollup.aggregation) {
+    case "sum":
+      return nums.reduce((sum, v) => sum + v, 0);
+    case "avg":
+      return nums.reduce((sum, v) => sum + v, 0) / nums.length;
+    case "min":
+      return Math.min(...nums);
+    case "max":
+      return Math.max(...nums);
+    default:
+      return null;
+  }
+}
+
+// src/utils.ts
+function getFieldValue(record, field, db, resolveDatabase) {
+  if (field.type === "rollup") {
+    return computeRollupValue(record, field, db, resolveDatabase);
+  }
+  if (field.type === "formula") {
+    return computeFormulaValue(record, field);
+  }
+  return record[field.id];
+}
+function getFieldDisplayValue(record, fieldId, schema, db, resolveDatabase) {
+  const field = schema?.find((f) => f.id === fieldId);
+  const val = field && db ? getFieldValue(record, field, db, resolveDatabase) : record[fieldId];
+  if (val === null || val === void 0) return "";
+  if (Array.isArray(val)) return val.join(", ");
+  if (typeof val === "boolean") return val ? "\u2713" : "\u2014";
+  return String(val);
+}
+function getRecordTitle(record, schema) {
+  const titleField = schema.find((f) => f.type === "text");
+  if (!titleField) return "Untitled";
+  const val = record[titleField.id];
+  return val !== null && val !== void 0 && val !== "" ? String(val) : "Untitled";
+}
+function getVisibleFields(schema, view) {
+  const order = view.fieldOrder ?? schema.map((f) => f.id);
+  const hidden = new Set(view.hiddenFields ?? []);
+  return order.map((id) => schema.find((f) => f.id === id)).filter((f) => f !== void 0 && !hidden.has(f.id));
+}
+function getStatusColor(value) {
+  return STATUS_GROUPS[value]?.color ?? "#5e5e5e";
+}
+function getFieldOptionColor(field, option) {
+  const explicit = field.optionColors?.[option];
+  if (explicit) return explicit;
+  const options = field.options ?? [];
+  const index = options.indexOf(option);
+  if (index >= 0) return DEFAULT_OPTION_COLORS[index % DEFAULT_OPTION_COLORS.length];
+  return DEFAULT_OPTION_COLORS[0];
+}
+function getReadableTextColor(background) {
+  const hex = background.replace("#", "").trim();
+  if (!/^[0-9a-fA-F]{6}$/.test(hex)) return "#ffffff";
+  const r = parseInt(hex.slice(0, 2), 16);
+  const g = parseInt(hex.slice(2, 4), 16);
+  const b = parseInt(hex.slice(4, 6), 16);
+  const luminance = (0.2126 * r + 0.7152 * g + 0.0722 * b) / 255;
+  return luminance > 0.62 ? "#1f2937" : "#ffffff";
+}
+
+// src/sort-filter.ts
+function applySorts(records, sorts, schema, db, resolveDatabase) {
+  if (!sorts.length) return records;
+  return [...records].sort((a, b) => {
+    for (const s of sorts) {
+      const field = schema?.find((f) => f.id === s.fieldId);
+      const av = field && db ? getFieldValue(a, field, db, resolveDatabase) : a[s.fieldId] ?? "";
+      const bv = field && db ? getFieldValue(b, field, db, resolveDatabase) : b[s.fieldId] ?? "";
+      const cmp = compareValues(av, bv);
+      if (cmp !== 0) return s.direction === "asc" ? cmp : -cmp;
+    }
+    return 0;
+  });
+}
+function applyFilters(records, filters, schema, db, resolveDatabase) {
+  if (!filters.length) return records;
+  return records.filter(
+    (record) => filters.every((f) => {
+      const field = schema?.find((candidate) => candidate.id === f.fieldId);
+      const val = field && db ? getFieldValue(record, field, db, resolveDatabase) : record[f.fieldId];
+      const strVal = valueAsFilterString(val);
+      const filterVal = f.value.toLowerCase();
+      switch (f.op) {
+        case "contains":
+          return strVal.includes(filterVal);
+        case "not_contains":
+          return !strVal.includes(filterVal);
+        case "equals":
+          return strVal === filterVal;
+        case "not_equals":
+          return strVal !== filterVal;
+        case "is_empty":
+          return val === null || val === void 0 || val === "" || Array.isArray(val) && val.length === 0;
+        case "is_not_empty":
+          return val !== null && val !== void 0 && val !== "" && !(Array.isArray(val) && val.length === 0);
+        case "gt":
+          return Number(val) > Number(f.value);
+        case "gte":
+          return Number(val) >= Number(f.value);
+        case "lt":
+          return Number(val) < Number(f.value);
+        case "lte":
+          return Number(val) <= Number(f.value);
+        default:
+          return true;
+      }
+    })
+  );
+}
+function compareValues(a, b) {
+  if ((a === null || a === void 0) && (b === null || b === void 0)) return 0;
+  if (a === null || a === void 0) return -1;
+  if (b === null || b === void 0) return 1;
+  if (typeof a === "number" && typeof b === "number") return a - b;
+  if (typeof a === "boolean" && typeof b === "boolean") return Number(a) - Number(b);
+  return valueAsFilterString(a).localeCompare(valueAsFilterString(b), void 0, { numeric: true, sensitivity: "base" });
+}
+function valueAsFilterString(value) {
+  if (value === null || value === void 0) return "";
+  if (Array.isArray(value)) return value.map((item) => String(item)).join(", ").toLowerCase();
+  if (typeof value === "boolean") return value ? "true" : "false";
+  return String(value).toLowerCase();
+}
+
+// src/io.ts
+import { readFile, writeFile, readdir } from "fs/promises";
+import { join } from "path";
+import { homedir } from "os";
+function getGlobalDatabasePath() {
+  return join(homedir(), ".sogo", "globalDatabases");
+}
+async function readDatabaseFile(filePath) {
+  const content = await readFile(filePath, "utf-8");
+  const db = JSON.parse(content);
+  db.schema ??= [];
+  db.views ??= [];
+  db.records ??= [];
+  for (const view of db.views) {
+    view.sort ??= [];
+    view.filter ??= [];
+    view.hiddenFields ??= [];
+  }
+  return db;
+}
+async function writeDatabaseFile(db, filePath) {
+  await writeFile(filePath, JSON.stringify(db, null, "	"), "utf-8");
+}
+async function scanDirectory(dirPath, depth = 3) {
+  const results = [];
+  await scanDirectoryRecursive(dirPath, results, depth);
+  return results;
+}
+async function scanDirectoryRecursive(dirPath, results, depth) {
+  if (depth <= 0) return;
+  try {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join(dirPath, entry.name);
+      if (!entry.isDirectory() && entry.name.endsWith(".db.json")) {
+        try {
+          const db = await readDatabaseFile(fullPath);
+          results.push({ db, path: fullPath });
+        } catch {
+        }
+      } else if (entry.isDirectory() && depth > 1 && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+        await scanDirectoryRecursive(fullPath, results, depth - 1);
+      }
+    }
+  } catch {
+  }
+}
+async function scanAll(workspacePath, globalPath, scanDepth = 3) {
+  const seenIds = /* @__PURE__ */ new Set();
+  const results = [];
+  const resolvedGlobalPath = globalPath ?? getGlobalDatabasePath();
+  const globalResults = await scanDirectory(resolvedGlobalPath, 2);
+  for (const entry of globalResults) {
+    if (!seenIds.has(entry.db.id)) {
+      seenIds.add(entry.db.id);
+      results.push({ ...entry, scope: "global" });
+    }
+  }
+  const workspaceResults = await scanDirectory(workspacePath, scanDepth);
+  for (const entry of workspaceResults) {
+    if (!seenIds.has(entry.db.id)) {
+      seenIds.add(entry.db.id);
+      results.push({ ...entry, scope: "workspace" });
+    }
+  }
+  return results;
+}
+
+// src/migration.ts
+function migrateSchema(db, newSchema) {
+  const oldSchema = db.schema ?? [];
+  const newFieldById = new Map(newSchema.map((f) => [f.id, f]));
+  const newFieldIds = new Set(newSchema.map((f) => f.id));
+  for (const record of db.records) {
+    for (const oldField of oldSchema) {
+      if (!newFieldIds.has(oldField.id)) {
+        delete record[oldField.id];
+      }
+    }
+    for (const newField of newSchema) {
+      const oldField = oldSchema.find((f) => f.id === newField.id);
+      const previousValue = record[newField.id];
+      if (oldField && oldField.type === newField.type && previousValue !== void 0) continue;
+      record[newField.id] = coerceValueForField(newField, previousValue);
+    }
+  }
+  const fallbackGroupBy = newSchema.find((f) => f.type === "status" || f.type === "select")?.id;
+  for (const view of db.views) {
+    view.sort = (view.sort ?? []).filter((s) => newFieldById.has(s.fieldId));
+    view.filter = (view.filter ?? []).filter((f) => newFieldById.has(f.fieldId));
+    view.hiddenFields = (view.hiddenFields ?? []).filter((id) => newFieldById.has(id));
+    if (view.fieldOrder) {
+      const order = view.fieldOrder.filter((id) => newFieldById.has(id));
+      for (const field of newSchema) {
+        if (!order.includes(field.id)) order.push(field.id);
+      }
+      view.fieldOrder = order;
+    }
+    if (view.columnWidths) {
+      const kept = {};
+      for (const [fieldId, width] of Object.entries(view.columnWidths)) {
+        if (newFieldById.has(fieldId)) kept[fieldId] = width;
+      }
+      view.columnWidths = kept;
+    }
+    if ((view.type === "kanban" || view.type === "gallery") && (!view.groupBy || !newFieldById.has(view.groupBy))) {
+      view.groupBy = fallbackGroupBy;
+    }
+  }
+  db.schema = newSchema.map((f) => ({ ...f, options: f.options ? [...f.options] : void 0 }));
+}
+function coerceValueForField(field, value) {
+  if (value === void 0 || value === null || value === "") {
+    if (field.type === "multiselect" || field.type === "relation") return [];
+    if (field.type === "rollup" || field.type === "formula") return null;
+    if (field.type === "createdAt" || field.type === "lastEditedAt") return (/* @__PURE__ */ new Date()).toISOString();
+    return null;
+  }
+  switch (field.type) {
+    case "number": {
+      const num = typeof value === "number" ? value : Number(value);
+      return Number.isFinite(num) ? num : null;
+    }
+    case "checkbox":
+      if (typeof value === "boolean") return value;
+      if (typeof value === "number") return value !== 0;
+      if (typeof value === "string") {
+        const normalized = value.trim().toLowerCase();
+        return normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on";
+      }
+      return false;
+    case "multiselect":
+      if (Array.isArray(value)) return value.map((item) => String(item)).filter(Boolean);
+      if (typeof value === "string") return value.split(/[;,]/).map((item) => item.trim()).filter(Boolean);
+      return [];
+    case "relation":
+      if (Array.isArray(value)) return value.map((item) => String(item)).filter(Boolean);
+      if (typeof value === "string") return value.split(/[;,]/).map((item) => item.trim()).filter(Boolean);
+      return [];
+    case "rollup":
+    case "formula":
+      return null;
+    case "select":
+    case "status": {
+      const normalized = Array.isArray(value) ? value[0] ?? null : value;
+      const candidate = normalized === null || normalized === void 0 ? null : String(normalized);
+      if (!candidate) return null;
+      if (field.options?.length && !field.options.includes(candidate)) return null;
+      return candidate;
+    }
+    case "createdAt":
+    case "lastEditedAt":
+    case "text":
+    case "date":
+    case "url":
+    case "email":
+    case "phone":
+      return String(value);
+  }
+}
+
+// src/templates.ts
+function createDefaultDatabaseTemplate(name) {
+  const titleId = crypto.randomUUID();
+  const statusId = crypto.randomUUID();
+  return {
+    id: crypto.randomUUID(),
+    name,
+    schema: [
+      { id: titleId, name: "Title", type: "text" },
+      { id: statusId, name: "Status", type: "status", options: [...STATUS_OPTIONS] }
+    ],
+    views: [
+      {
+        id: crypto.randomUUID(),
+        name: "All Items",
+        type: "table",
+        sort: [],
+        filter: [],
+        hiddenFields: []
+      },
+      {
+        id: crypto.randomUUID(),
+        name: "Kanban",
+        type: "kanban",
+        groupBy: statusId,
+        sort: [],
+        filter: [],
+        hiddenFields: []
+      }
+    ],
+    records: []
+  };
+}
+function createTaskDatabaseTemplate(name) {
+  const titleId = crypto.randomUUID();
+  const statusId = crypto.randomUUID();
+  const priorityId = crypto.randomUUID();
+  const dueDateId = crypto.randomUUID();
+  const effortId = crypto.randomUUID();
+  const blockedId = crypto.randomUUID();
+  const projectsId = crypto.randomUUID();
+  return {
+    id: crypto.randomUUID(),
+    name,
+    schema: [
+      { id: titleId, name: "Title", type: "text" },
+      { id: statusId, name: "Status", type: "status", options: [...STATUS_OPTIONS] },
+      { id: priorityId, name: "Priority", type: "select", options: ["Low", "Medium", "High"] },
+      { id: dueDateId, name: "Due Date", type: "date" },
+      { id: effortId, name: "Effort", type: "number" },
+      { id: blockedId, name: "Blocked", type: "checkbox" },
+      { id: projectsId, name: "Project", type: "relation", relation: {} }
+    ],
+    views: [
+      {
+        id: crypto.randomUUID(),
+        name: "All Tasks",
+        type: "table",
+        sort: [{ fieldId: dueDateId, direction: "asc" }],
+        filter: [],
+        hiddenFields: []
+      },
+      {
+        id: crypto.randomUUID(),
+        name: "By Status",
+        type: "kanban",
+        groupBy: statusId,
+        sort: [],
+        filter: [],
+        hiddenFields: []
+      },
+      {
+        id: crypto.randomUUID(),
+        name: "Calendar",
+        type: "calendar",
+        groupBy: dueDateId,
+        sort: [],
+        filter: [],
+        hiddenFields: []
+      }
+    ],
+    records: []
+  };
+}
+function isTasksDatabaseName(name) {
+  return /\btask(s)?\b/i.test(name.trim());
+}
+function createDatabase(name) {
+  return isTasksDatabaseName(name) ? createTaskDatabaseTemplate(name) : createDefaultDatabaseTemplate(name);
+}
+
+// src/csv.ts
+function exportCsv(db) {
+  const { schema } = db;
+  const headers = ["id", ...schema.map((f) => f.name)];
+  const rows = [headers.map(csvEscape).join(",")];
+  for (const record of db.records) {
+    const cells = [
+      csvEscape(record.id),
+      ...schema.map((f) => {
+        const val = record[f.id];
+        if (val === null || val === void 0) return "";
+        if (Array.isArray(val)) return csvEscape(val.join(";"));
+        return csvEscape(String(val));
+      })
+    ];
+    rows.push(cells.join(","));
+  }
+  return rows.join("\r\n");
+}
+function importCsvRecords(db, csvText, fieldMap) {
+  const lines = csvText.split(/\r?\n/).filter((l) => l.trim());
+  if (lines.length < 2) return [];
+  const headers = parseCsvRow(lines[0]);
+  const records = [];
+  for (let i = 1; i < lines.length; i++) {
+    const cells = parseCsvRow(lines[i]);
+    const record = { id: crypto.randomUUID() };
+    for (let j = 0; j < headers.length; j++) {
+      const csvHeader = headers[j];
+      const fieldId = fieldMap[csvHeader];
+      if (!fieldId) continue;
+      const field = db.schema.find((f) => f.id === fieldId);
+      if (!field) continue;
+      const raw = cells[j] ?? "";
+      record[fieldId] = coerceCsvValue(field, raw);
+    }
+    records.push(record);
+  }
+  return records;
+}
+function coerceCsvValue(field, raw) {
+  if (field.type === "number") {
+    return raw === "" ? null : Number(raw);
+  }
+  if (field.type === "checkbox") {
+    return raw.toLowerCase() === "true" || raw === "1";
+  }
+  if (field.type === "multiselect") {
+    return raw ? raw.split(";").map((s) => s.trim()) : [];
+  }
+  return raw || null;
+}
+function csvEscape(val) {
+  if (val.includes(",") || val.includes('"') || val.includes("\n")) {
+    return `"${val.replace(/"/g, '""')}"`;
+  }
+  return val;
+}
+function parseCsvRow(line) {
+  const cells = [];
+  let cur = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (ch === '"') {
+      if (inQuotes && line[i + 1] === '"') {
+        cur += '"';
+        i++;
+      } else {
+        inQuotes = !inQuotes;
+      }
+    } else if (ch === "," && !inQuotes) {
+      cells.push(cur);
+      cur = "";
+    } else {
+      cur += ch;
+    }
+  }
+  cells.push(cur);
+  return cells;
+}
+export {
+  DEFAULT_OPTION_COLORS,
+  STATUS_GROUPS,
+  STATUS_OPTIONS,
+  applyFilters,
+  applySorts,
+  coerceValueForField,
+  computeFormulaValue,
+  computeRollupValue,
+  createDatabase,
+  createDefaultDatabaseTemplate,
+  createTaskDatabaseTemplate,
+  evaluateFormulaToken,
+  exportCsv,
+  getFieldDisplayValue,
+  getFieldOptionColor,
+  getFieldValue,
+  getGlobalDatabasePath,
+  getReadableTextColor,
+  getRecordTitle,
+  getRelationTargetDatabase,
+  getStatusColor,
+  getVisibleFields,
+  importCsvRecords,
+  inferImplicitRelationTargets,
+  isTasksDatabaseName,
+  migrateSchema,
+  readDatabaseFile,
+  scanAll,
+  scanDirectory,
+  writeDatabaseFile
+};
+//# sourceMappingURL=index.js.map