@aglyn/aglyn 1.0.0-beta.143

package/src/lib/app-utils/csv-import.js

@@ -0,0 +1,279 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * 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.
+ */ /**
+ * READING A SPREADSHEET INTO A CRM COLLECTION — the part that does not care
+ * which collection (AGL-2621).
+ *
+ * The contact import (AGL-2602) settled how a file becomes records: a
+ * header row is matched against an alias table to PROPOSE a column → field
+ * mapping, the operator corrects it, one line is mapped to a raw row of
+ * verbatim strings, and the server judges each row and tallies what it did.
+ * A companies file goes through the same three stages with a different
+ * field list, so the stages live here, parametric over the field union, and
+ * the CRM plugin's contact and company importers each supply their vocabulary
+ * — the fields, their aliases, their labels — and nothing else.
+ *
+ * ## A custom target is `custom:<key>`
+ *
+ * A column may also map to a custom field the merchant defined, which has
+ * no standard name. The target is one string rather than a discriminated
+ * object because it is the VALUE of a select control and travels through a
+ * form; the prefix is what tells the two apart on the way back.
+ *
+ * ## The ceilings are shared numbers
+ *
+ * One file, one request and one preview are bounded the same way for every
+ * collection, because the bounds are about the browser's memory and a
+ * console request's budget, not about what the rows hold.
+ */ /**
+ * The most rows one uploaded file may carry.
+ *
+ * A bound on the work one import represents and on the memory the browser
+ * holds while mapping it — five thousand rows of a wide export is already
+ * several megabytes of cells in a tab. A larger list is split and imported
+ * in pieces; the drawer says so on the file, before a single row is sent.
+ */ export const CSV_IMPORT_MAX_ROWS = 5000;
+/**
+ * Rows per request.
+ *
+ * Each row costs the server a lookup and a write, plus whatever a name it
+ * has not seen in this request costs to resolve; two hundred of those sit
+ * comfortably inside a console request's budget and give the progress bar
+ * twenty-five steps on the largest file the drawer accepts.
+ */ export const CSV_IMPORT_CHUNK_SIZE = 200;
+/**
+ * The most bytes one request may carry, checked before the body is judged.
+ *
+ * Two hundred rows of a wide export with long values is well under a
+ * megabyte; two megabytes is the line past which a request is not a chunk
+ * of a file but something else being pushed through this door.
+ */ export const CSV_IMPORT_MAX_BODY_BYTES = 2000000;
+/** How many mapped rows the drawer shows before the operator commits. */ export const CSV_IMPORT_PREVIEW_ROWS = 10;
+/** The prefix a custom-field target id carries. */ const CUSTOM_TARGET_PREFIX = 'custom:';
+/** The custom-field target id for a definition key. */ export function customImportTarget(key) {
+    return `${CUSTOM_TARGET_PREFIX}${key}`;
+}
+/** The definition key a custom target names, or `null` for a standard field. */ export function customImportTargetKey(target) {
+    return target.startsWith(CUSTOM_TARGET_PREFIX) ? target.slice(CUSTOM_TARGET_PREFIX.length) : null;
+}
+/**
+ * Normalizes a header cell for alias matching.
+ *
+ * Underscores, dots and hyphens all become one space, so `e-mail`,
+ * `email_address` and `Email Address` compare as the words they are. The
+ * alias tables are written in the human spelling and pass through the same
+ * function, so a table stays readable and the comparison stays exact.
+ */ export function importHeaderKey(value) {
+    return String(value != null ? value : '').trim().toLowerCase().replace(/[_.\-/]+/g, ' ').replace(/\s+/g, ' ').trim();
+}
+/** An alias table, normalized once through {@link importHeaderKey}. */ export function importAliasKeys(fields, aliases) {
+    const keys = {};
+    for (const field of fields){
+        keys[field] = new Set(aliases[field].map(importHeaderKey));
+    }
+    return keys;
+}
+export function guessImportMapping(columns, fields, aliasKeys, customFields = []) {
+    const mapping = {};
+    const taken = new Set();
+    const customByHeader = new Map();
+    for (const field of customFields){
+        customByHeader.set(importHeaderKey(field.label), field.key);
+        customByHeader.set(importHeaderKey(field.key), field.key);
+    }
+    columns.forEach((column, index)=>{
+        const key = importHeaderKey(column);
+        if (!key) return;
+        const customKey = customByHeader.get(key);
+        if (customKey) {
+            const target = customImportTarget(customKey);
+            if (!taken.has(target)) {
+                mapping[index] = target;
+                taken.add(target);
+            }
+            return;
+        }
+        for (const field of fields){
+            if (taken.has(field)) continue;
+            if (aliasKeys[field].has(key)) {
+                mapping[index] = field;
+                taken.add(field);
+                return;
+            }
+        }
+    });
+    return mapping;
+}
+/**
+ * One parsed line under a mapping: the cells the mapping selected, under the
+ * field they were mapped to, verbatim, with custom values gathered under
+ * `custom` by definition key. Empty cells are left absent.
+ */ export function mapImportRow(cells, mapping) {
+    const standard = {};
+    const custom = {};
+    for (const [indexText, target] of Object.entries(mapping)){
+        var _cells_Number;
+        const value = String((_cells_Number = cells[Number(indexText)]) != null ? _cells_Number : '');
+        if (!value.trim()) continue;
+        const customKey = customImportTargetKey(target);
+        if (customKey) {
+            custom[customKey] = value;
+        } else {
+            standard[target] = value;
+        }
+    }
+    return Object.keys(custom).length ? _extends({}, standard, {
+        custom
+    }) : standard;
+}
+/**
+ * A tag cell as the tags it names.
+ *
+ * `|` or `,` separated — the CSV export writes `|`, most other products
+ * write `,` — lowercased and trimmed like a record's own tag field, so an
+ * imported `VIP` and a typed `vip` are one tag and not two.
+ */ export function parseImportTags(value, max) {
+    const parts = Array.isArray(value) ? value.map((entry)=>String(entry != null ? entry : '')) : String(value != null ? value : '').split(/[|,]/);
+    return [
+        ...new Set(parts.map((tag)=>tag.trim().toLowerCase()).filter(Boolean))
+    ].slice(0, max);
+}
+/**
+ * A yes/no cell as a boolean, or `null` when it is neither.
+ *
+ * The affirmatives are the ones consent and checkbox columns actually
+ * carry; the negatives are listed so that an explicit `no` is a `false`
+ * rather than an unreadable value that gets reported as dropped.
+ */ export function parseImportFlag(value) {
+    if (typeof value === 'boolean') return value;
+    if (typeof value === 'number') return value === 1 ? true : value === 0 ? false : null;
+    const text = String(value != null ? value : '').trim().toLowerCase();
+    if ([
+        'yes',
+        'y',
+        'true',
+        '1',
+        'on',
+        'subscribed',
+        'opted in',
+        'opted-in'
+    ].includes(text)) {
+        return true;
+    }
+    if ([
+        'no',
+        'n',
+        'false',
+        '0',
+        'off',
+        'unsubscribed',
+        ''
+    ].includes(text)) {
+        return false;
+    }
+    return null;
+}
+/** A cell as trimmed text capped at `max`, or `undefined` when blank. */ export function importTextValue(value, max) {
+    const text = String(value != null ? value : '').trim().slice(0, max);
+    return text || undefined;
+}
+/** A CSV cell, quoted only when it has to be. */ export function csvCell(value) {
+    const text = String(value != null ? value : '');
+    return /[",\r\n]/.test(text) ? `"${text.replace(/"/g, '""')}"` : text;
+}
+/**
+ * A whole CSV — the header, then one line per row — through {@link csvCell}.
+ *
+ * The one serializer for every CSV the console writes: each CRM section's
+ * export, the skipped-rows file an import hands back and each report
+ * table's export.
+ * Quoting is decided in {@link csvCell} and nowhere else — a cell holding a
+ * comma, a quote or a line break is wrapped in quotes with its quotes
+ * doubled, no other cell is touched, and a `null` or `undefined` cell is
+ * empty rather than the word — so that a report's file and a contacts file
+ * open the same way in a spreadsheet.
+ */ export function csvDocument(header, rows) {
+    return [
+        header,
+        ...rows
+    ].map((line)=>line.map(csvCell).join(',')).join('\n');
+}
+/**
+ * The skipped rows as a file the operator can fix and re-import.
+ *
+ * The original columns verbatim plus a trailing `Skipped because` column,
+ * so the file round-trips: correct the cell, delete the last column or
+ * leave it unmapped, and import it again.
+ */ export function importSkippedCsv(columns, entries, labels) {
+    return csvDocument([
+        ...columns,
+        'Skipped because'
+    ], entries.map((entry)=>{
+        var _labels_entry_reason;
+        return [
+            ...columns.map((_column, index)=>{
+                var _entry_cells_index;
+                return (_entry_cells_index = entry.cells[index]) != null ? _entry_cells_index : '';
+            }),
+            (_labels_entry_reason = labels[entry.reason]) != null ? _labels_entry_reason : entry.reason
+        ];
+    }));
+}
+/** An empty tally, for the drawer to fold chunk results into. */ export function emptyImportResult() {
+    return {
+        received: 0,
+        created: 0,
+        merged: 0,
+        skipped: [],
+        dropped: {},
+        ownersUnresolved: []
+    };
+}
+/**
+ * Two results as one.
+ *
+ * `offset` is where the chunk started in the file, so a skipped row's index
+ * comes back as its position in the FILE rather than in the request — which
+ * is what the download of skipped rows has to look up.
+ */ export function mergeImportResults(total, chunk, offset = 0) {
+    var _chunk_dropped, _chunk_received, _chunk_created, _chunk_merged, _chunk_skipped, _chunk_ownersUnresolved;
+    const dropped = _extends({}, total.dropped);
+    for (const [field, count] of Object.entries((_chunk_dropped = chunk.dropped) != null ? _chunk_dropped : {})){
+        var _dropped_field;
+        dropped[field] = ((_dropped_field = dropped[field]) != null ? _dropped_field : 0) + Number(count != null ? count : 0);
+    }
+    return {
+        received: total.received + Number((_chunk_received = chunk.received) != null ? _chunk_received : 0),
+        created: total.created + Number((_chunk_created = chunk.created) != null ? _chunk_created : 0),
+        merged: total.merged + Number((_chunk_merged = chunk.merged) != null ? _chunk_merged : 0),
+        skipped: [
+            ...total.skipped,
+            ...((_chunk_skipped = chunk.skipped) != null ? _chunk_skipped : []).map((entry)=>_extends({}, entry, {
+                    index: Number(entry.index) + offset
+                }))
+        ],
+        dropped,
+        ownersUnresolved: [
+            ...new Set([
+                ...total.ownersUnresolved,
+                ...(_chunk_ownersUnresolved = chunk.ownersUnresolved) != null ? _chunk_ownersUnresolved : []
+            ])
+        ]
+    };
+}
+
+//# sourceMappingURL=csv-import.js.map

package/src/lib/app-utils/csv-import.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../libs/aglyn/src/lib/app-utils/csv-import.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * READING A SPREADSHEET INTO A CRM COLLECTION — the part that does not care\n * which collection (AGL-2621).\n *\n * The contact import (AGL-2602) settled how a file becomes records: a\n * header row is matched against an alias table to PROPOSE a column → field\n * mapping, the operator corrects it, one line is mapped to a raw row of\n * verbatim strings, and the server judges each row and tallies what it did.\n * A companies file goes through the same three stages with a different\n * field list, so the stages live here, parametric over the field union, and\n * the CRM plugin's contact and company importers each supply their vocabulary\n * — the fields, their aliases, their labels — and nothing else.\n *\n * ## A custom target is `custom:<key>`\n *\n * A column may also map to a custom field the merchant defined, which has\n * no standard name. The target is one string rather than a discriminated\n * object because it is the VALUE of a select control and travels through a\n * form; the prefix is what tells the two apart on the way back.\n *\n * ## The ceilings are shared numbers\n *\n * One file, one request and one preview are bounded the same way for every\n * collection, because the bounds are about the browser's memory and a\n * console request's budget, not about what the rows hold.\n */\n\n/**\n * The most rows one uploaded file may carry.\n *\n * A bound on the work one import represents and on the memory the browser\n * holds while mapping it — five thousand rows of a wide export is already\n * several megabytes of cells in a tab. A larger list is split and imported\n * in pieces; the drawer says so on the file, before a single row is sent.\n */\nexport const CSV_IMPORT_MAX_ROWS = 5_000\n\n/**\n * Rows per request.\n *\n * Each row costs the server a lookup and a write, plus whatever a name it\n * has not seen in this request costs to resolve; two hundred of those sit\n * comfortably inside a console request's budget and give the progress bar\n * twenty-five steps on the largest file the drawer accepts.\n */\nexport const CSV_IMPORT_CHUNK_SIZE = 200\n\n/**\n * The most bytes one request may carry, checked before the body is judged.\n *\n * Two hundred rows of a wide export with long values is well under a\n * megabyte; two megabytes is the line past which a request is not a chunk\n * of a file but something else being pushed through this door.\n */\nexport const CSV_IMPORT_MAX_BODY_BYTES = 2_000_000\n\n/** How many mapped rows the drawer shows before the operator commits. */\nexport const CSV_IMPORT_PREVIEW_ROWS = 10\n\n/** The prefix a custom-field target id carries. */\nconst CUSTOM_TARGET_PREFIX = 'custom:'\n\n/** The custom-field target id for a definition key. */\nexport function customImportTarget(key: string): `custom:${string}` {\n  return `${CUSTOM_TARGET_PREFIX}${key}`\n}\n\n/** The definition key a custom target names, or `null` for a standard field. */\nexport function customImportTargetKey(target: string): string | null {\n  return target.startsWith(CUSTOM_TARGET_PREFIX)\n    ? target.slice(CUSTOM_TARGET_PREFIX.length)\n    : null\n}\n\n/**\n * Normalizes a header cell for alias matching.\n *\n * Underscores, dots and hyphens all become one space, so `e-mail`,\n * `email_address` and `Email Address` compare as the words they are. The\n * alias tables are written in the human spelling and pass through the same\n * function, so a table stays readable and the comparison stays exact.\n */\nexport function importHeaderKey(value: unknown): string {\n  return String(value ?? '')\n    .trim()\n    .toLowerCase()\n    .replace(/[_.\\-/]+/g, ' ')\n    .replace(/\\s+/g, ' ')\n    .trim()\n}\n\n/** An alias table, normalized once through {@link importHeaderKey}. */\nexport function importAliasKeys<F extends string>(\n  fields: readonly F[],\n  aliases: Record<F, readonly string[]>,\n): Record<F, ReadonlySet<string>> {\n  const keys = {} as Record<F, ReadonlySet<string>>\n  for (const field of fields) {\n    keys[field] = new Set(aliases[field].map(importHeaderKey))\n  }\n  return keys\n}\n\n/**\n * A proposed mapping from a file's header row.\n *\n * Custom fields win over standard aliases when a header matches a\n * definition's label or key exactly — a merchant who defined a field called\n * \"Status\" meant THEIR status, not our lifecycle stage. Each target is\n * taken at most once, by the first column that claims it, so a file with two\n * columns named \"Email\" maps the first and leaves the second for the\n * operator to decide.\n */\nexport function guessImportMapping<F extends string>(\n  columns: readonly string[],\n  fields: readonly F[],\n  aliasKeys: Record<F, ReadonlySet<string>>,\n): Record<number, F>\nexport function guessImportMapping<F extends string>(\n  columns: readonly string[],\n  fields: readonly F[],\n  aliasKeys: Record<F, ReadonlySet<string>>,\n  customFields: readonly { key: string; label: string }[],\n): Record<number, F | `custom:${string}`>\nexport function guessImportMapping<F extends string>(\n  columns: readonly string[],\n  fields: readonly F[],\n  aliasKeys: Record<F, ReadonlySet<string>>,\n  customFields: readonly { key: string; label: string }[] = [],\n): Record<number, F | `custom:${string}`> {\n  const mapping: Record<number, F | `custom:${string}`> = {}\n  const taken = new Set<string>()\n  const customByHeader = new Map<string, string>()\n  for (const field of customFields) {\n    customByHeader.set(importHeaderKey(field.label), field.key)\n    customByHeader.set(importHeaderKey(field.key), field.key)\n  }\n  columns.forEach((column, index) => {\n    const key = importHeaderKey(column)\n    if (!key) return\n    const customKey = customByHeader.get(key)\n    if (customKey) {\n      const target = customImportTarget(customKey)\n      if (!taken.has(target)) {\n        mapping[index] = target\n        taken.add(target)\n      }\n      return\n    }\n    for (const field of fields) {\n      if (taken.has(field)) continue\n      if (aliasKeys[field].has(key)) {\n        mapping[index] = field\n        taken.add(field)\n        return\n      }\n    }\n  })\n  return mapping\n}\n\n/**\n * One parsed line under a mapping: the cells the mapping selected, under the\n * field they were mapped to, verbatim, with custom values gathered under\n * `custom` by definition key. Empty cells are left absent.\n */\nexport function mapImportRow<F extends string>(\n  cells: readonly string[],\n  mapping: Record<number, F | `custom:${string}`>,\n): Partial<Record<F, string>> & { custom?: Record<string, string> } {\n  const standard: Partial<Record<F, string>> = {}\n  const custom: Record<string, string> = {}\n  for (const [indexText, target] of Object.entries(mapping)) {\n    const value = String(cells[Number(indexText)] ?? '')\n    if (!value.trim()) continue\n    const customKey = customImportTargetKey(target)\n    if (customKey) {\n      custom[customKey] = value\n    } else {\n      standard[target as F] = value\n    }\n  }\n  return Object.keys(custom).length ? { ...standard, custom } : standard\n}\n\n/**\n * A tag cell as the tags it names.\n *\n * `|` or `,` separated — the CSV export writes `|`, most other products\n * write `,` — lowercased and trimmed like a record's own tag field, so an\n * imported `VIP` and a typed `vip` are one tag and not two.\n */\nexport function parseImportTags(value: unknown, max: number): string[] {\n  const parts = Array.isArray(value)\n    ? value.map((entry) => String(entry ?? ''))\n    : String(value ?? '').split(/[|,]/)\n  return [\n    ...new Set(parts.map((tag) => tag.trim().toLowerCase()).filter(Boolean)),\n  ].slice(0, max)\n}\n\n/**\n * A yes/no cell as a boolean, or `null` when it is neither.\n *\n * The affirmatives are the ones consent and checkbox columns actually\n * carry; the negatives are listed so that an explicit `no` is a `false`\n * rather than an unreadable value that gets reported as dropped.\n */\nexport function parseImportFlag(value: unknown): boolean | null {\n  if (typeof value === 'boolean') return value\n  if (typeof value === 'number') return value === 1 ? true : value === 0 ? false : null\n  const text = String(value ?? '')\n    .trim()\n    .toLowerCase()\n  if (['yes', 'y', 'true', '1', 'on', 'subscribed', 'opted in', 'opted-in'].includes(text)) {\n    return true\n  }\n  if (['no', 'n', 'false', '0', 'off', 'unsubscribed', ''].includes(text)) {\n    return false\n  }\n  return null\n}\n\n/** A cell as trimmed text capped at `max`, or `undefined` when blank. */\nexport function importTextValue(value: unknown, max: number): string | undefined {\n  const text = String(value ?? '')\n    .trim()\n    .slice(0, max)\n  return text || undefined\n}\n\n/** A cell the file carried that could not be read as the field it was mapped to. */\nexport interface ImportDroppedValue {\n  /** The standard field name, or `custom:<key>`. */\n  field: string\n  value: string\n}\n\n/** A CSV cell, quoted only when it has to be. */\nexport function csvCell(value: unknown): string {\n  const text = String(value ?? '')\n  return /[\",\\r\\n]/.test(text) ? `\"${text.replace(/\"/g, '\"\"')}\"` : text\n}\n\n/**\n * A whole CSV — the header, then one line per row — through {@link csvCell}.\n *\n * The one serializer for every CSV the console writes: each CRM section's\n * export, the skipped-rows file an import hands back and each report\n * table's export.\n * Quoting is decided in {@link csvCell} and nowhere else — a cell holding a\n * comma, a quote or a line break is wrapped in quotes with its quotes\n * doubled, no other cell is touched, and a `null` or `undefined` cell is\n * empty rather than the word — so that a report's file and a contacts file\n * open the same way in a spreadsheet.\n */\nexport function csvDocument(\n  header: readonly unknown[],\n  rows: readonly (readonly unknown[])[],\n): string {\n  return [header, ...rows]\n    .map((line) => line.map(csvCell).join(','))\n    .join('\\n')\n}\n\n/**\n * The skipped rows as a file the operator can fix and re-import.\n *\n * The original columns verbatim plus a trailing `Skipped because` column,\n * so the file round-trips: correct the cell, delete the last column or\n * leave it unmapped, and import it again.\n */\nexport function importSkippedCsv<R extends string>(\n  columns: readonly string[],\n  entries: readonly { cells: readonly string[]; reason: R }[],\n  labels: Record<R, string>,\n): string {\n  return csvDocument(\n    [...columns, 'Skipped because'],\n    entries.map((entry) => [\n      ...columns.map((_column, index) => entry.cells[index] ?? ''),\n      labels[entry.reason] ?? entry.reason,\n    ]),\n  )\n}\n\n/**\n * One row the server did not store, by its index in the request. Each\n * collection names the row back to the operator in its own field — an\n * address, a company name — beside these two.\n */\nexport interface ImportSkippedRow<R extends string> {\n  index: number\n  reason: R\n}\n\n/**\n * What one request did, in the shape every collection's import reports.\n * The drawer sums these across a file; a collection with more to say\n * extends the shape and folds its own field beside {@link mergeImportResults}.\n */\nexport interface ImportChunkResult<S extends ImportSkippedRow<string>> {\n  received: number\n  created: number\n  merged: number\n  skipped: S[]\n  /** Unreadable cells, tallied by field. */\n  dropped: Record<string, number>\n  /** Owner addresses that matched no member of the organization. */\n  ownersUnresolved: string[]\n}\n\n/** An empty tally, for the drawer to fold chunk results into. */\nexport function emptyImportResult<\n  S extends ImportSkippedRow<string>,\n>(): ImportChunkResult<S> {\n  return {\n    received: 0,\n    created: 0,\n    merged: 0,\n    skipped: [],\n    dropped: {},\n    ownersUnresolved: [],\n  }\n}\n\n/**\n * Two results as one.\n *\n * `offset` is where the chunk started in the file, so a skipped row's index\n * comes back as its position in the FILE rather than in the request — which\n * is what the download of skipped rows has to look up.\n */\nexport function mergeImportResults<S extends ImportSkippedRow<string>>(\n  total: ImportChunkResult<S>,\n  chunk: Partial<ImportChunkResult<S>>,\n  offset = 0,\n): ImportChunkResult<S> {\n  const dropped = { ...total.dropped }\n  for (const [field, count] of Object.entries(chunk.dropped ?? {})) {\n    dropped[field] = (dropped[field] ?? 0) + Number(count ?? 0)\n  }\n  return {\n    received: total.received + Number(chunk.received ?? 0),\n    created: total.created + Number(chunk.created ?? 0),\n    merged: total.merged + Number(chunk.merged ?? 0),\n    skipped: [\n      ...total.skipped,\n      ...(chunk.skipped ?? []).map((entry) => ({\n        ...entry,\n        index: Number(entry.index) + offset,\n      })),\n    ],\n    dropped,\n    ownersUnresolved: [\n      ...new Set([...total.ownersUnresolved, ...(chunk.ownersUnresolved ?? [])]),\n    ],\n  }\n}\n"],"names":["CSV_IMPORT_MAX_ROWS","CSV_IMPORT_CHUNK_SIZE","CSV_IMPORT_MAX_BODY_BYTES","CSV_IMPORT_PREVIEW_ROWS","CUSTOM_TARGET_PREFIX","customImportTarget","key","customImportTargetKey","target","startsWith","slice","length","importHeaderKey","value","String","trim","toLowerCase","replace","importAliasKeys","fields","aliases","keys","field","Set","map","guessImportMapping","columns","aliasKeys","customFields","mapping","taken","customByHeader","Map","set","label","forEach","column","index","customKey","get","has","add","mapImportRow","cells","standard","custom","indexText","Object","entries","Number","parseImportTags","max","parts","Array","isArray","entry","split","tag","filter","Boolean","parseImportFlag","text","includes","importTextValue","undefined","csvCell","test","csvDocument","header","rows","line","join","importSkippedCsv","labels","_column","reason","emptyImportResult","received","created","merged","skipped","dropped","ownersUnresolved","mergeImportResults","total","chunk","offset","count"],"mappings":"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"}

package/src/lib/app-utils/dataset-csv.d.ts

@@ -0,0 +1,109 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * 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.
+ */
+/**
+ * Dataset CSV/JSON serialization (AGL-182). The predictable inverse of
+ * `coerceDocumentValues`: ISO dates, `lat, lon` coordinates, comma-joined
+ * lists, JSON maps, reference ids — so an export re-imports losslessly
+ * through the same coercion.
+ *
+ * **Why this lives in core rather than in `@aglyn/plugins-data`** (AGL-2335).
+ * AGL-413 moved dataset io out to the plugin, and the dataset-shaped half of
+ * the import machinery — column mapping against a `DatasetModel` — is still
+ * there, correctly: nothing outside that plugin maps a file onto a dataset.
+ *
+ * Writing one is different now. `/api/orgs/datasets/export` streams a
+ * dataset from the server, and `scope:app` may not import a lib tagged
+ * `aglyn:addons` — apps reach plugins only through the generated loader
+ * manifests (AGL-417/419). The choice was a second copy of the escaper in
+ * the console or one copy somewhere both may reach. There are already five
+ * divergent hand-rolled CSV escapers in this repo; this is not becoming the
+ * sixth. `dataset-io.ts` re-exports every name below, so the plugin's own
+ * imports are unchanged.
+ *
+ * READING one is shared for the same reason. The email list importer parses
+ * a merchant's contact file, and it lives in `@aglyn/plugins-email`, which
+ * may not import `@aglyn/plugins-data` either. So {@link parseCsv} sits here
+ * beside the escaper that is its inverse, and `dataset-io.ts` re-exports it
+ * exactly as it re-exports the writing half.
+ */
+import type { DatasetFieldDefinition, DatasetModel } from './dataset-models';
+/** Storage value → portable string (CSV cell / JSON value). */
+export declare function serializeDatasetValue(field: DatasetFieldDefinition, value: unknown): string;
+/**
+ * The header line — field ids, in model order (AGL-2335).
+ *
+ * Split out of {@link datasetRecordsToCsv} so a server export can emit the
+ * file a page at a time. The whole point of that export is that it is not
+ * bounded by what one process can hold in memory, and a helper that only
+ * takes a complete `rows` array cannot serve it. Everything below shares
+ * one escaper: there are already five divergent hand-rolled CSV escapers in
+ * this repo and this is not becoming the sixth.
+ */
+export declare function datasetCsvHeader(model: DatasetModel): string;
+/** One record's values (storage form) → one CSV line, no terminator. */
+export declare function datasetCsvRow(model: DatasetModel, row: Record<string, unknown>): string;
+/** One record's values → the portable JSON object the JSON export emits. */
+export declare function datasetRecordToJson(model: DatasetModel, row: Record<string, unknown>): Record<string, string>;
+/**
+ * Data rows in a CSV document — the header excluded, quoted newlines not
+ * counted as row breaks (AGL-2335).
+ *
+ * This exists so a download can be CHECKED against the row count the server
+ * promised, rather than trusted. A truncated export is the defect this whole
+ * area is about, and a stream that dies halfway produces a perfectly
+ * well-formed shorter file: nothing about the bytes says they are short.
+ *
+ * Single pass, no array building — {@link parseCsv} answers the same
+ * question but materializes every cell, which is the wrong trade when the
+ * file may be hundreds of thousands of rows and the only thing wanted is
+ * how many there are.
+ */
+export declare function countCsvDataRows(text: string): number;
+/**
+ * Did a downloaded export arrive whole? (AGL-2335)
+ *
+ * The server streams and reports its `count()` aggregate in a header, so the
+ * client can CHECK rather than trust. This is the check, kept here as a pure
+ * function because a guard living inline in a component is a guard nobody
+ * can force red — and this one exists precisely to catch a silent shortfall.
+ *
+ * `short` is only true when the count is both KNOWN and lower. A missing or
+ * unparseable header is not evidence of truncation, and refusing a download
+ * on the strength of a header that never arrived would fail the user for the
+ * server's bookkeeping. More rows than promised is not short either — the
+ * count is a snapshot taken before the first page, so a concurrent insert
+ * can legitimately overtake it.
+ */
+export declare function exportShortfall(promisedHeader: string | null | undefined, body: string, format: 'csv' | 'json'): {
+    promised: number;
+    received: number;
+    short: boolean;
+};
+/** Rows (storage-form value maps) → CSV with a fieldId header row. */
+export declare function datasetRecordsToCsv(model: DatasetModel, rows: Array<Record<string, unknown>>): string;
+/**
+ * Minimal RFC-4180 CSV parser (quoted fields, escaped quotes, CRLF).
+ *
+ * The inverse of the escaper above, and the one parser in the repo — see the
+ * module note for why the email list importer reaches this rather than
+ * writing its own.
+ *
+ * A wholly blank row is dropped. Every spreadsheet writes a trailing newline
+ * and a row of empty cells is not a record; carrying it through would give
+ * every caller the same off-by-one to remember.
+ */
+export declare function parseCsv(text: string): string[][];

package/src/lib/app-utils/dataset-csv.js

@@ -0,0 +1,235 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * 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.
+ */ /**
+ * Dataset CSV/JSON serialization (AGL-182). The predictable inverse of
+ * `coerceDocumentValues`: ISO dates, `lat, lon` coordinates, comma-joined
+ * lists, JSON maps, reference ids — so an export re-imports losslessly
+ * through the same coercion.
+ *
+ * **Why this lives in core rather than in `@aglyn/plugins-data`** (AGL-2335).
+ * AGL-413 moved dataset io out to the plugin, and the dataset-shaped half of
+ * the import machinery — column mapping against a `DatasetModel` — is still
+ * there, correctly: nothing outside that plugin maps a file onto a dataset.
+ *
+ * Writing one is different now. `/api/orgs/datasets/export` streams a
+ * dataset from the server, and `scope:app` may not import a lib tagged
+ * `aglyn:addons` — apps reach plugins only through the generated loader
+ * manifests (AGL-417/419). The choice was a second copy of the escaper in
+ * the console or one copy somewhere both may reach. There are already five
+ * divergent hand-rolled CSV escapers in this repo; this is not becoming the
+ * sixth. `dataset-io.ts` re-exports every name below, so the plugin's own
+ * imports are unchanged.
+ *
+ * READING one is shared for the same reason. The email list importer parses
+ * a merchant's contact file, and it lives in `@aglyn/plugins-email`, which
+ * may not import `@aglyn/plugins-data` either. So {@link parseCsv} sits here
+ * beside the escaper that is its inverse, and `dataset-io.ts` re-exports it
+ * exactly as it re-exports the writing half.
+ */ /** Storage value → portable string (CSV cell / JSON value). */ export function serializeDatasetValue(field, value) {
+    if (value == null) return '';
+    switch(field.type){
+        case 'timestamp':
+            return typeof value === 'number' && Number.isFinite(value) ? new Date(value).toISOString() : String(value);
+        case 'coordinates':
+            {
+                const coordinates = value;
+                return coordinates && typeof coordinates.latitude === 'number' && typeof coordinates.longitude === 'number' ? `${coordinates.latitude}, ${coordinates.longitude}` : String(value);
+            }
+        case 'sorted':
+        case 'reference':
+            return Array.isArray(value) ? value.join(', ') : String(value);
+        case 'map':
+            try {
+                return JSON.stringify(value);
+            } catch (unused) {
+                return String(value);
+            }
+        default:
+            return String(value);
+    }
+}
+const csvEscape = (cell)=>/[",\r\n]/.test(cell) ? `"${cell.replace(/"/g, '""')}"` : cell;
+/**
+ * The header line — field ids, in model order (AGL-2335).
+ *
+ * Split out of {@link datasetRecordsToCsv} so a server export can emit the
+ * file a page at a time. The whole point of that export is that it is not
+ * bounded by what one process can hold in memory, and a helper that only
+ * takes a complete `rows` array cannot serve it. Everything below shares
+ * one escaper: there are already five divergent hand-rolled CSV escapers in
+ * this repo and this is not becoming the sixth.
+ */ export function datasetCsvHeader(model) {
+    return model.order.map(csvEscape).join(',');
+}
+/** One record's values (storage form) → one CSV line, no terminator. */ export function datasetCsvRow(model, row) {
+    return model.order.map((fieldId)=>{
+        const field = model.fields[fieldId];
+        return csvEscape(field ? serializeDatasetValue(field, row[fieldId]) : '');
+    }).join(',');
+}
+/** One record's values → the portable JSON object the JSON export emits. */ export function datasetRecordToJson(model, row) {
+    return Object.fromEntries(model.order.map((fieldId)=>{
+        const field = model.fields[fieldId];
+        return [
+            fieldId,
+            field ? serializeDatasetValue(field, row[fieldId]) : ''
+        ];
+    }));
+}
+/**
+ * Data rows in a CSV document — the header excluded, quoted newlines not
+ * counted as row breaks (AGL-2335).
+ *
+ * This exists so a download can be CHECKED against the row count the server
+ * promised, rather than trusted. A truncated export is the defect this whole
+ * area is about, and a stream that dies halfway produces a perfectly
+ * well-formed shorter file: nothing about the bytes says they are short.
+ *
+ * Single pass, no array building — {@link parseCsv} answers the same
+ * question but materializes every cell, which is the wrong trade when the
+ * file may be hundreds of thousands of rows and the only thing wanted is
+ * how many there are.
+ */ export function countCsvDataRows(text) {
+    const source = String(text != null ? text : '');
+    if (!source) return 0;
+    let rows = 0;
+    let quoted = false;
+    let cellsSeen = false;
+    for(let index = 0; index < source.length; index += 1){
+        const char = source[index];
+        if (quoted) {
+            if (char === '"') {
+                if (source[index + 1] === '"') index += 1;
+                else quoted = false;
+            }
+            cellsSeen = true;
+            continue;
+        }
+        if (char === '"') {
+            quoted = true;
+            cellsSeen = true;
+            continue;
+        }
+        if (char === '\n') {
+            rows += 1;
+            cellsSeen = false;
+            continue;
+        }
+        if (char !== '\r') cellsSeen = true;
+    }
+    // A file that does not end in a newline still has a final row.
+    if (cellsSeen) rows += 1;
+    // The header is not data.
+    return Math.max(0, rows - 1);
+}
+/**
+ * Did a downloaded export arrive whole? (AGL-2335)
+ *
+ * The server streams and reports its `count()` aggregate in a header, so the
+ * client can CHECK rather than trust. This is the check, kept here as a pure
+ * function because a guard living inline in a component is a guard nobody
+ * can force red — and this one exists precisely to catch a silent shortfall.
+ *
+ * `short` is only true when the count is both KNOWN and lower. A missing or
+ * unparseable header is not evidence of truncation, and refusing a download
+ * on the strength of a header that never arrived would fail the user for the
+ * server's bookkeeping. More rows than promised is not short either — the
+ * count is a snapshot taken before the first page, so a concurrent insert
+ * can legitimately overtake it.
+ */ export function exportShortfall(promisedHeader, body, format) {
+    const promised = Number(promisedHeader);
+    let received;
+    if (format === 'csv') {
+        received = countCsvDataRows(body);
+    } else {
+        try {
+            const parsed = JSON.parse(body);
+            received = Array.isArray(parsed) ? parsed.length : 0;
+        } catch (unused) {
+            // A body that is not JSON at all did not arrive whole.
+            return {
+                promised,
+                received: 0,
+                short: true
+            };
+        }
+    }
+    return {
+        promised,
+        received,
+        short: Number.isFinite(promised) && promisedHeader != null && received < promised
+    };
+}
+/** Rows (storage-form value maps) → CSV with a fieldId header row. */ export function datasetRecordsToCsv(model, rows) {
+    return [
+        datasetCsvHeader(model),
+        ...rows.map((row)=>datasetCsvRow(model, row))
+    ].join('\n');
+}
+/**
+ * Minimal RFC-4180 CSV parser (quoted fields, escaped quotes, CRLF).
+ *
+ * The inverse of the escaper above, and the one parser in the repo — see the
+ * module note for why the email list importer reaches this rather than
+ * writing its own.
+ *
+ * A wholly blank row is dropped. Every spreadsheet writes a trailing newline
+ * and a row of empty cells is not a record; carrying it through would give
+ * every caller the same off-by-one to remember.
+ */ export function parseCsv(text) {
+    const rows = [];
+    let row = [];
+    let cell = '';
+    let quoted = false;
+    const source = String(text != null ? text : '');
+    for(let index = 0; index < source.length; index += 1){
+        const char = source[index];
+        if (quoted) {
+            if (char === '"') {
+                if (source[index + 1] === '"') {
+                    cell += '"';
+                    index += 1;
+                } else {
+                    quoted = false;
+                }
+            } else {
+                cell += char;
+            }
+            continue;
+        }
+        if (char === '"') {
+            quoted = true;
+        } else if (char === ',') {
+            row.push(cell);
+            cell = '';
+        } else if (char === '\n' || char === '\r') {
+            if (char === '\r' && source[index + 1] === '\n') index += 1;
+            row.push(cell);
+            cell = '';
+            rows.push(row);
+            row = [];
+        } else {
+            cell += char;
+        }
+    }
+    if (cell !== '' || row.length) {
+        row.push(cell);
+        rows.push(row);
+    }
+    return rows.filter((cells)=>cells.some((value)=>value.trim() !== ''));
+}
+
+//# sourceMappingURL=dataset-csv.js.map