biblioplex 0.1.1 → 0.2.1

package/vendor/deckExport.js

@@ -1,219 +0,0 @@
-const PRESETS = new Set(['plain', 'moxfield', 'arena', 'mtgo', 'csv', 'json']);
-const ALL_BOARDS = ['main', 'sideboard', 'maybe'];
-
-function clean(value) {
-  return value == null ? '' : String(value).trim();
-}
-
-function quantity(card) {
-  const qty = Number.parseInt(card?.qty, 10);
-  return Number.isFinite(qty) && qty > 0 ? qty : 1;
-}
-
-function cardName(card) {
-  return clean(card?.resolvedName || card?.name);
-}
-
-function deckBoard(card) {
-  const board = clean(card?.deckBoard).toLowerCase();
-  return board === 'sideboard' || board === 'maybe' ? board : 'main';
-}
-
-function setCode(card) {
-  return clean(card?.setCode || card?.set).toUpperCase();
-}
-
-function collectorNumber(card) {
-  return clean(card?.cn || card?.collectorNumber || card?.collector_number);
-}
-
-function finishMarker(card) {
-  const finish = clean(card?.finish).toLowerCase();
-  if (finish === 'foil') return '*F*';
-  if (finish === 'etched' || finish === 'etched foil') return '*E*';
-  return '';
-}
-
-function titleSlug(deckMeta) {
-  const title = clean(deckMeta?.title || deckMeta?.name || 'deck');
-  return title.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'deck';
-}
-
-function normalizePreset(preset) {
-  const value = clean(preset || 'plain').toLowerCase();
-  return PRESETS.has(value) ? value : 'plain';
-}
-
-function selectedBoardsForPreset(preset, options) {
-  if (Array.isArray(options.boards)) {
-    const boards = options.boards.map(b => clean(b).toLowerCase()).filter(b => ALL_BOARDS.includes(b));
-    if (boards.length) return boards;
-  }
-  if (preset === 'moxfield' || preset === 'csv' || preset === 'json') return [...ALL_BOARDS];
-  return ['main', 'sideboard'];
-}
-
-function cloneEntry(card, qty = quantity(card)) {
-  return { card, qty, name: cardName(card), board: deckBoard(card) };
-}
-
-function collapseByName(entries) {
-  const byName = new Map();
-  for (const entry of entries) {
-    const key = entry.name.toLowerCase();
-    const existing = byName.get(key);
-    if (existing) existing.qty += entry.qty;
-    else byName.set(key, { ...entry });
-  }
-  return [...byName.values()];
-}
-
-function lineNameCard(name) {
-  return { name, resolvedName: name, qty: 1 };
-}
-
-function extractCommanderSlot(slotName, rawName, mainEntries, warnings) {
-  const name = clean(rawName);
-  if (!name) return null;
-  const match = mainEntries.find(entry => entry.qty > 0 && entry.name === name);
-  if (!match) {
-    warnings.push(`${slotName} "${name}" was not found in the mainboard; exported as name-only.`);
-    return { card: lineNameCard(name), qty: 1, name, board: 'commander', nameOnly: true, slot: slotName };
-  }
-  match.qty -= 1;
-  return { card: match.card, qty: 1, name: match.name, board: 'commander', slot: slotName };
-}
-
-function entriesForText(entries, preset) {
-  return preset === 'moxfield' ? entries : collapseByName(entries);
-}
-
-function sectionLines(label, entries, options = {}) {
-  if (!entries.length) return [];
-  return [label, ...entries.map(entry => formatDeckTextLine({ ...entry.card, qty: entry.qty }, options))];
-}
-
-function csvCell(value) {
-  const text = value == null ? '' : String(value);
-  return /[",\r\n]/.test(text) ? `"${text.replaceAll('"', '""')}"` : text;
-}
-
-function csvRows(sections) {
-  const rows = [['board', 'quantity', 'name', 'setCode', 'cn', 'finish']];
-  for (const board of ['commander', ...ALL_BOARDS]) {
-    for (const entry of sections[board] || []) {
-      rows.push([
-        board,
-        entry.qty,
-        entry.name,
-        clean(entry.card?.setCode || entry.card?.set),
-        collectorNumber(entry.card),
-        clean(entry.card?.finish || 'normal'),
-      ]);
-    }
-  }
-  return rows.map(row => row.map(csvCell).join(',')).join('\n');
-}
-
-export function defaultDeckExportOptions(preset) {
-  const normalized = normalizePreset(preset);
-  return {
-    preset: normalized,
-    boards: selectedBoardsForPreset(normalized, {}),
-    includeCommander: true,
-    collapsePrintings: !['moxfield', 'csv', 'json'].includes(normalized),
-  };
-}
-
-export function buildDeckExportSections(list, deckMeta = {}, options = {}) {
-  const preset = normalizePreset(options.preset);
-  const selectedBoards = selectedBoardsForPreset(preset, options);
-  const warnings = [];
-  const sections = { commander: [], main: [], sideboard: [], maybe: [] };
-
-  for (const card of list || []) {
-    const name = cardName(card);
-    if (!name) continue;
-    const board = deckBoard(card);
-    if (!selectedBoards.includes(board)) continue;
-    sections[board].push(cloneEntry(card));
-  }
-
-  if (options.includeCommander !== false) {
-    const commander = extractCommanderSlot('commander', deckMeta?.commander, sections.main, warnings);
-    const partner = extractCommanderSlot('partner', deckMeta?.partner, sections.main, warnings);
-    sections.commander = [commander, partner].filter(Boolean);
-    sections.main = sections.main.filter(entry => entry.qty > 0);
-  }
-
-  if (options.collapsePrintings ?? defaultDeckExportOptions(preset).collapsePrintings) {
-    for (const board of ALL_BOARDS) sections[board] = collapseByName(sections[board]);
-  }
-
-  return { sections, warnings, boards: selectedBoards, preset };
-}
-
-export function formatDeckTextLine(card, options = {}) {
-  const preset = normalizePreset(options.preset);
-  const qty = quantity(card);
-  const name = cardName(card);
-  if (preset !== 'moxfield') return `${qty} ${name}`;
-
-  const parts = [`${qty} ${name}`];
-  const set = setCode(card);
-  const cn = collectorNumber(card);
-  if (set && cn) parts.push(`(${set}) ${cn}`);
-  const marker = finishMarker(card);
-  if (marker) parts.push(marker);
-  return parts.join(' ');
-}
-
-export function buildDeckExport(list, deckMeta = {}, options = {}) {
-  const preset = normalizePreset(options.preset);
-  const opts = { ...defaultDeckExportOptions(preset), ...options, preset };
-  const { sections, warnings } = buildDeckExportSections(list, deckMeta, opts);
-  const filenameBase = titleSlug(deckMeta);
-
-  if (preset === 'json') {
-    const output = {
-      preset,
-      metadata: { ...deckMeta },
-      boards: Object.fromEntries(
-        ['commander', ...ALL_BOARDS].map(board => [
-          board,
-          (sections[board] || []).map(entry => ({ quantity: entry.qty, name: entry.name, card: entry.card })),
-        ]),
-      ),
-      warnings,
-    };
-    const body = JSON.stringify(output, null, 2);
-    return { body, mime: 'application/json', filename: `${filenameBase}.json`, output, warnings };
-  }
-
-  if (preset === 'csv') {
-    const body = csvRows(sections);
-    return { body, mime: 'text/csv', filename: `${filenameBase}.csv`, output: sections, warnings };
-  }
-
-  const lines = [];
-  if (sections.commander.length) {
-    lines.push(...sectionLines('Commander', entriesForText(sections.commander, preset), opts), '');
-  }
-
-  if (preset === 'arena') {
-    lines.push(...sectionLines('Deck', entriesForText(sections.main, preset), opts));
-    if (sections.sideboard.length) lines.push('', ...sectionLines('Sideboard', entriesForText(sections.sideboard, preset), opts));
-  } else if (preset === 'mtgo') {
-    lines.push(...entriesForText(sections.main, preset).map(entry => formatDeckTextLine({ ...entry.card, qty: entry.qty }, opts)));
-    lines.push(...entriesForText(sections.sideboard, preset).map(entry => `SB: ${formatDeckTextLine({ ...entry.card, qty: entry.qty }, opts)}`));
-  } else {
-    lines.push(...sectionLines('Mainboard', entriesForText(sections.main, preset), opts));
-    if (sections.sideboard.length) lines.push('', ...sectionLines('Sideboard', entriesForText(sections.sideboard, preset), opts));
-    if ((preset === 'moxfield' || opts.boards.includes('maybe')) && sections.maybe.length) {
-      lines.push('', ...sectionLines('Maybeboard', entriesForText(sections.maybe, preset), opts));
-    }
-  }
-
-  const body = lines.join('\n').replace(/\n+$/g, '');
-  return { body, mime: 'text/plain', filename: `${filenameBase}-${preset}.txt`, output: sections, warnings };
-}

package/vendor/importMerge.js

@@ -1,22 +0,0 @@
-import { collectionKey } from './collection.js';
-import { mergeSource } from './adapters.js';
-
-// Pure: takes (existing, imported) -> new collection. Dedupes by collectionKey,
-// sums qty on collisions, unions tags on collisions, merges per-format
-// `_source` metadata so re-imports don't drop earlier preserved fields.
-export function mergeIntoCollection(existing, imported) {
-  const byKey = new Map();
-  for (const c of existing) byKey.set(collectionKey(c), c);
-  for (const c of imported) {
-    const k = collectionKey(c);
-    if (byKey.has(k)) {
-      const e = byKey.get(k);
-      e.qty += c.qty;
-      e.tags = [...new Set([...(e.tags || []), ...(c.tags || [])])];
-      mergeSource(e, c);
-    } else {
-      byKey.set(k, c);
-    }
-  }
-  return Array.from(byKey.values());
-}

package/vendor/importParsing.js

@@ -1,119 +0,0 @@
-import { makeEntry, normalizeTag } from './collection.js';
-
-// ---- CSV parser (handles quoted fields) ----
-export function parseCsv(text) {
-  const rows = [];
-  let row = [];
-  let cell = '';
-  let inQuotes = false;
-  for (let i = 0; i < text.length; i++) {
-    const ch = text[i];
-    if (inQuotes) {
-      if (ch === '"') {
-        if (text[i + 1] === '"') { cell += '"'; i++; }
-        else inQuotes = false;
-      } else {
-        cell += ch;
-      }
-    } else {
-      if (ch === '"') inQuotes = true;
-      else if (ch === ',') { row.push(cell); cell = ''; }
-      else if (ch === '\n' || ch === '\r') {
-        if (ch === '\r' && text[i + 1] === '\n') i++;
-        row.push(cell); cell = '';
-        if (row.length > 1 || row[0] !== '') rows.push(row);
-        row = [];
-      } else {
-        cell += ch;
-      }
-    }
-  }
-  if (cell || row.length) { row.push(cell); rows.push(row); }
-  return rows.filter(r => r.some(c => c !== ''));
-}
-
-// ---- Header alias mapping ----
-export const ALIASES = {
-  name:       ['name', 'card name', 'card'],
-  setCode:    ['set code', 'set', 'edition', 'setcode', 'set_code'],
-  setName:    ['set name', 'setname', 'edition name'],
-  cn:         ['collector number', 'card number', 'cn', 'collector_number', 'number'],
-  finish:     ['foil', 'finish', 'printing'],
-  qty:        ['quantity', 'count', 'qty'],
-  condition:  ['condition'],
-  language:   ['language', 'lang'],
-  location:   ['location', 'place', 'storage', 'where'],
-  scryfallId: ['scryfall id', 'scryfall_id', 'scryfallid'],
-  rarity:     ['rarity'],
-  price:      ['purchase price', 'price', 'tcg market price'],
-  tags:       ['tags'],
-};
-
-export function mapHeaders(headerRow) {
-  const idx = {};
-  const lower = headerRow.map(h => h.toLowerCase().trim());
-  for (const [key, aliases] of Object.entries(ALIASES)) {
-    for (const a of aliases) {
-      const i = lower.indexOf(a);
-      if (i !== -1) { idx[key] = i; break; }
-    }
-  }
-  return idx;
-}
-
-export function parseDecklist(text, options = {}) {
-  const { location = '' } = options;
-  const entries = [];
-  const errors = [];
-  const lines = text.split(/\r?\n/);
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i].trim();
-    if (!line || line.startsWith('//')) continue;
-    const match = line.match(/^(\d+)\s+(.+?)\s+\(([^)]+)\)\s+(\S+)(?:\s+(.*))?$/);
-    if (!match) {
-      errors.push(i + 1);
-      continue;
-    }
-    const [, qty, name, setCode, cn, markerText = ''] = match;
-    const markers = markerText.toUpperCase();
-    const finish = markers.includes('*E*') ? 'etched' : markers.includes('*F*') ? 'foil' : 'normal';
-    entries.push(makeEntry({ qty, name, setCode, cn, finish, location }));
-  }
-  return { entries, errors };
-}
-
-// ---- Tags CSV cell helpers ----
-// Pipe-delimited. Inside a tag, '\' escapes itself ('\\') and '|' ('\|').
-// Walk char-by-char so escapes can't be ambiguated by a tag literally
-// ending in backslash (the bug was: ['foo\\', 'bar'] would naively
-// serialize as 'foo\|bar' and round-trip back as the single tag 'foo|bar').
-export function parseTagsCell(cell) {
-  if (!cell) return [];
-  const tags = [];
-  let cur = '';
-  for (let i = 0; i < cell.length; i++) {
-    const ch = cell[i];
-    if (ch === '\\' && i + 1 < cell.length) {
-      const next = cell[i + 1];
-      if (next === '\\' || next === '|') {
-        cur += next;
-        i++;
-        continue;
-      }
-    }
-    if (ch === '|') {
-      tags.push(cur);
-      cur = '';
-    } else {
-      cur += ch;
-    }
-  }
-  tags.push(cur);
-  return tags.map(s => normalizeTag(s)).filter(Boolean);
-}
-
-export function serializeTagsCell(tags) {
-  if (!Array.isArray(tags) || tags.length === 0) return '';
-  // Escape '\' first, then '|'. Order matters.
-  return tags.map(t => String(t).replace(/\\/g, '\\\\').replace(/\|/g, '\\|')).join('|');
-}

package/vendor/portableArchive.js

@@ -1,151 +0,0 @@
-import { ensureContainersForCollection } from './collection.js';
-import { applyLoadedState } from './state.js';
-import { normalizeStoredAppData, serializeAppState } from './storageSchema.js';
-
-export const PORTABLE_ARCHIVE_KIND = 'mtgcollection.archive';
-export const PORTABLE_ARCHIVE_VERSION = 1;
-
-function isPlainObject(value) {
-  return value && typeof value === 'object' && !Array.isArray(value);
-}
-
-function cloneJson(value, fallback) {
-  if (value == null) return fallback;
-  try {
-    return JSON.parse(JSON.stringify(value));
-  } catch (e) {
-    return fallback;
-  }
-}
-
-export function normalizeHistory(raw) {
-  if (!Array.isArray(raw)) return [];
-  return raw
-    .filter(isPlainObject)
-    .map(ev => cloneJson(ev, null))
-    .filter(Boolean);
-}
-
-export function normalizeShareRecords(raw) {
-  if (!Array.isArray(raw)) return [];
-  return raw
-    .filter(isPlainObject)
-    .map(record => ({
-      shareId: String(record.shareId || record.id || '').trim(),
-      containerKey: String(record.containerKey || '').trim(),
-      kind: String(record.kind || 'deck'),
-      owned: Boolean(record.owned),
-      createdAt: Number.isFinite(record.createdAt) ? record.createdAt : null,
-      updatedAt: Number.isFinite(record.updatedAt) ? record.updatedAt : null,
-    }))
-    .filter(record => record.shareId);
-}
-
-export function extractShareRecords(appData) {
-  const out = [];
-  const containers = isPlainObject(appData?.containers) ? appData.containers : {};
-  for (const [containerKey, container] of Object.entries(containers)) {
-    if (!container || container.type !== 'deck' || !container.shareId) continue;
-    out.push({
-      shareId: String(container.shareId),
-      containerKey,
-      kind: 'deck',
-      owned: false,
-      createdAt: container.createdAt || null,
-      updatedAt: container.updatedAt || null,
-    });
-  }
-  return out;
-}
-
-export function makeSyncSnapshot({ app, history = [], shares = [] } = {}) {
-  const appData = normalizeStoredAppData(app);
-  if (!appData) return null;
-  return {
-    app: appData,
-    history: normalizeHistory(history),
-    shares: normalizeShareRecords(shares.length ? shares : extractShareRecords(appData)),
-  };
-}
-
-export function captureSyncSnapshot(stateRef, { history = [] } = {}) {
-  return makeSyncSnapshot({
-    app: serializeAppState(stateRef),
-    history,
-  });
-}
-
-export function buildPortableArchive({ stateRef = null, snapshot = null, history = [] } = {}) {
-  const syncSnapshot = snapshot
-    ? makeSyncSnapshot(snapshot)
-    : captureSyncSnapshot(stateRef, { history });
-  if (!syncSnapshot) return null;
-  return {
-    kind: PORTABLE_ARCHIVE_KIND,
-    version: PORTABLE_ARCHIVE_VERSION,
-    exportedAt: new Date().toISOString(),
-    snapshot: syncSnapshot,
-  };
-}
-
-export function normalizePortableArchive(raw) {
-  if (!isPlainObject(raw)) return null;
-  if (raw.kind === PORTABLE_ARCHIVE_KIND) {
-    const version = Number(raw.version || 1);
-    if (version !== PORTABLE_ARCHIVE_VERSION) return null;
-    const snapshot = makeSyncSnapshot(raw.snapshot || raw);
-    if (!snapshot) return null;
-    return {
-      kind: PORTABLE_ARCHIVE_KIND,
-      version: PORTABLE_ARCHIVE_VERSION,
-      exportedAt: typeof raw.exportedAt === 'string' ? raw.exportedAt : '',
-      snapshot,
-    };
-  }
-
-  // Accept the existing raw localStorage shape as a convenience import.
-  const legacyApp = normalizeStoredAppData(raw.app || raw);
-  if (!legacyApp) return null;
-  return buildPortableArchive({
-    snapshot: {
-      app: legacyApp,
-      history: normalizeHistory(raw.history),
-      shares: normalizeShareRecords(raw.shares),
-    },
-  });
-}
-
-export function portableArchiveToJson(archive) {
-  return JSON.stringify(archive, null, 2);
-}
-
-export function parsePortableArchiveJson(text) {
-  try {
-    return normalizePortableArchive(JSON.parse(text));
-  } catch (e) {
-    return null;
-  }
-}
-
-export function applySyncSnapshotToState(snapshot, {
-  applyLoadedStateImpl = applyLoadedState,
-  ensureContainersForCollectionImpl = ensureContainersForCollection,
-  replaceHistoryImpl = null,
-} = {}) {
-  const normalized = makeSyncSnapshot(snapshot);
-  if (!normalized) return false;
-  const app = normalized.app;
-  applyLoadedStateImpl({
-    collection: app.collection,
-    containers: app.containers,
-    viewMode: app.ui.viewMode,
-    activeLocation: null,
-    viewAsList: app.ui.viewAsList,
-    selectedFormat: app.ui.selectedFormat,
-    sortField: app.ui.sortField,
-    sortDir: app.ui.sortDir,
-  });
-  ensureContainersForCollectionImpl();
-  if (typeof replaceHistoryImpl === 'function') replaceHistoryImpl(normalized.history);
-  return true;
-}