@aglyn/shared-data-enums 1.0.0-beta.143

package/src/lib/breakpoint-span.d.ts

@@ -0,0 +1,66 @@
+/**
+ * @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.
+ */
+/**
+ * The responsive span/offset syntax the besigner persists for MUI Grid
+ * (AGL-2486).
+ *
+ * A Grid cell's `size` and `offset` are stored as ONE string in the node's
+ * props — `"6"`, `"auto"`, `"xs:12 md:6"` — because MUI v6+ replaced the
+ * per-breakpoint `xs=`/`md=` props with a single value-or-object prop. That
+ * string is the persisted format and it does not change here; what changes is
+ * that the attributes panel no longer asks an author to TYPE it (a developer
+ * syntax nobody outside the docs knows). Parse and serialize live together in
+ * this shared module, the same arrangement `parseCssDimension`/
+ * `buildCssDimension` above have, so the editor and the renderer cannot drift
+ * into two different readings of the same stored string.
+ *
+ * `raw` is the escape hatch that keeps the editor from destroying what it
+ * cannot model — a half-typed pair, a `{{token}}` binding, an unknown
+ * breakpoint. The string comes back untouched instead of collapsing to
+ * whatever a lenient parse salvaged.
+ */
+/** Breakpoint keys MUI's responsive `size`/`offset` objects accept. */
+export declare const SPAN_BREAKPOINTS: readonly ["xs", "sm", "md", "lg", "xl"];
+export type SpanBreakpoint = (typeof SPAN_BREAKPOINTS)[number];
+/** One span: a column count, or one of MUI's two sizing keywords. */
+export type SpanValue = number | 'auto' | 'grow';
+export interface BreakpointSpan {
+    /**
+     * A value authored with NO breakpoint (`"6"`, `"auto"`). MUI applies it at
+     * every size, and it is mutually exclusive with {@link values} — the prop
+     * is either a scalar or an object, never both.
+     */
+    base?: SpanValue;
+    /** Per-breakpoint values, normalized into {@link SPAN_BREAKPOINTS} order. */
+    values?: Partial<Record<SpanBreakpoint, SpanValue>>;
+    /** Set ONLY when the string is not a span this module can model. */
+    raw?: string;
+}
+/**
+ * Reads a stored span string into {@link BreakpointSpan}.
+ *
+ * A partly-parseable list comes back as `raw`, never as a partial object: a
+ * half-applied breakpoint map is a layout that silently differs from what the
+ * author typed, which is worse than no layout at all.
+ */
+export declare function parseBreakpointSpan(value: string | number | undefined | null): BreakpointSpan;
+/**
+ * Serializes a {@link BreakpointSpan} back to the single string that gets
+ * persisted. The inverse of {@link parseBreakpointSpan}: an empty span
+ * serializes to an empty string, never to a partial pair like `md:`.
+ */
+export declare function buildBreakpointSpan(span?: BreakpointSpan): string;

package/src/lib/breakpoint-span.js

@@ -0,0 +1,117 @@
+/**
+ * @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.
+ */ /**
+ * The responsive span/offset syntax the besigner persists for MUI Grid
+ * (AGL-2486).
+ *
+ * A Grid cell's `size` and `offset` are stored as ONE string in the node's
+ * props — `"6"`, `"auto"`, `"xs:12 md:6"` — because MUI v6+ replaced the
+ * per-breakpoint `xs=`/`md=` props with a single value-or-object prop. That
+ * string is the persisted format and it does not change here; what changes is
+ * that the attributes panel no longer asks an author to TYPE it (a developer
+ * syntax nobody outside the docs knows). Parse and serialize live together in
+ * this shared module, the same arrangement `parseCssDimension`/
+ * `buildCssDimension` above have, so the editor and the renderer cannot drift
+ * into two different readings of the same stored string.
+ *
+ * `raw` is the escape hatch that keeps the editor from destroying what it
+ * cannot model — a half-typed pair, a `{{token}}` binding, an unknown
+ * breakpoint. The string comes back untouched instead of collapsing to
+ * whatever a lenient parse salvaged.
+ */ /** Breakpoint keys MUI's responsive `size`/`offset` objects accept. */ export const SPAN_BREAKPOINTS = [
+    'xs',
+    'sm',
+    'md',
+    'lg',
+    'xl'
+];
+/** `12`, `-4`, `2.5` — a bare quantity with no breakpoint attached. */ const BARE_NUMBER = /^-?\d+(\.\d+)?$/;
+/** `md:6`, `XS = auto` — one breakpoint pair, in either separator style. */ const PAIR = /^([a-z]+)\s*[:=]\s*(auto|grow|-?\d+(?:\.\d+)?)$/i;
+const isBreakpoint = (key)=>SPAN_BREAKPOINTS.includes(key);
+/**
+ * Reads a stored span string into {@link BreakpointSpan}.
+ *
+ * A partly-parseable list comes back as `raw`, never as a partial object: a
+ * half-applied breakpoint map is a layout that silently differs from what the
+ * author typed, which is worse than no layout at all.
+ */ export function parseBreakpointSpan(value) {
+    // `value === 0` is a real span the author can mean, so this tests for
+    // absence explicitly rather than for falsiness (strictNullChecks is off
+    // repo-wide, and `!value` would swallow the zero).
+    if (value === undefined || value === null || value === '') return {};
+    if (typeof value === 'number') {
+        return Number.isFinite(value) ? {
+            base: value
+        } : {};
+    }
+    const text = `${value}`.trim();
+    if (!text) return {};
+    if (text === 'auto' || text === 'grow') return {
+        base: text
+    };
+    if (BARE_NUMBER.test(text)) return {
+        base: Number(text)
+    };
+    const pairs = text.split(/[\s,]+/).filter(Boolean);
+    const values = {};
+    for (const pair of pairs){
+        var _match_, _match_1;
+        const match = PAIR.exec(pair);
+        if (!match) return {
+            raw: text
+        };
+        const key = ((_match_ = match[1]) != null ? _match_ : '').toLowerCase();
+        if (!isBreakpoint(key)) return {
+            raw: text
+        };
+        const span = (_match_1 = match[2]) != null ? _match_1 : '';
+        values[key] = span === 'auto' || span === 'grow' ? span : Number(span);
+    }
+    if (!Object.keys(values).length) return {
+        raw: text
+    };
+    // Normalized to breakpoint order so the serialized string is stable no
+    // matter what order the author wrote the pairs in.
+    const ordered = {};
+    for (const key of SPAN_BREAKPOINTS){
+        if (values[key] !== undefined) ordered[key] = values[key];
+    }
+    return {
+        values: ordered
+    };
+}
+/**
+ * Serializes a {@link BreakpointSpan} back to the single string that gets
+ * persisted. The inverse of {@link parseBreakpointSpan}: an empty span
+ * serializes to an empty string, never to a partial pair like `md:`.
+ */ export function buildBreakpointSpan(span) {
+    if (!span) return '';
+    if (span.raw !== undefined) return span.raw;
+    if (span.base !== undefined) return `${span.base}`;
+    const values = span.values;
+    if (!values) return '';
+    const pairs = [];
+    for (const key of SPAN_BREAKPOINTS){
+        const value = values[key];
+        if (value === undefined || value === null || value === '') {
+            continue;
+        }
+        pairs.push(`${key}:${value}`);
+    }
+    return pairs.join(' ');
+}
+
+//# sourceMappingURL=breakpoint-span.js.map

package/src/lib/breakpoint-span.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/shared/data/enums/src/lib/breakpoint-span.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 * The responsive span/offset syntax the besigner persists for MUI Grid\n * (AGL-2486).\n *\n * A Grid cell's `size` and `offset` are stored as ONE string in the node's\n * props — `\"6\"`, `\"auto\"`, `\"xs:12 md:6\"` — because MUI v6+ replaced the\n * per-breakpoint `xs=`/`md=` props with a single value-or-object prop. That\n * string is the persisted format and it does not change here; what changes is\n * that the attributes panel no longer asks an author to TYPE it (a developer\n * syntax nobody outside the docs knows). Parse and serialize live together in\n * this shared module, the same arrangement `parseCssDimension`/\n * `buildCssDimension` above have, so the editor and the renderer cannot drift\n * into two different readings of the same stored string.\n *\n * `raw` is the escape hatch that keeps the editor from destroying what it\n * cannot model — a half-typed pair, a `{{token}}` binding, an unknown\n * breakpoint. The string comes back untouched instead of collapsing to\n * whatever a lenient parse salvaged.\n */\n\n/** Breakpoint keys MUI's responsive `size`/`offset` objects accept. */\nexport const SPAN_BREAKPOINTS = ['xs', 'sm', 'md', 'lg', 'xl'] as const\n\nexport type SpanBreakpoint = (typeof SPAN_BREAKPOINTS)[number]\n\n/** One span: a column count, or one of MUI's two sizing keywords. */\nexport type SpanValue = number | 'auto' | 'grow'\n\nexport interface BreakpointSpan {\n  /**\n   * A value authored with NO breakpoint (`\"6\"`, `\"auto\"`). MUI applies it at\n   * every size, and it is mutually exclusive with {@link values} — the prop\n   * is either a scalar or an object, never both.\n   */\n  base?: SpanValue\n  /** Per-breakpoint values, normalized into {@link SPAN_BREAKPOINTS} order. */\n  values?: Partial<Record<SpanBreakpoint, SpanValue>>\n  /** Set ONLY when the string is not a span this module can model. */\n  raw?: string\n}\n\n/** `12`, `-4`, `2.5` — a bare quantity with no breakpoint attached. */\nconst BARE_NUMBER = /^-?\\d+(\\.\\d+)?$/\n/** `md:6`, `XS = auto` — one breakpoint pair, in either separator style. */\nconst PAIR = /^([a-z]+)\\s*[:=]\\s*(auto|grow|-?\\d+(?:\\.\\d+)?)$/i\n\nconst isBreakpoint = (key: string): key is SpanBreakpoint =>\n  (SPAN_BREAKPOINTS as readonly string[]).includes(key)\n\n/**\n * Reads a stored span string into {@link BreakpointSpan}.\n *\n * A partly-parseable list comes back as `raw`, never as a partial object: a\n * half-applied breakpoint map is a layout that silently differs from what the\n * author typed, which is worse than no layout at all.\n */\nexport function parseBreakpointSpan(\n  value: string | number | undefined | null,\n): BreakpointSpan {\n  // `value === 0` is a real span the author can mean, so this tests for\n  // absence explicitly rather than for falsiness (strictNullChecks is off\n  // repo-wide, and `!value` would swallow the zero).\n  if (value === undefined || value === null || value === '') return {}\n  if (typeof value === 'number') {\n    return Number.isFinite(value) ? { base: value } : {}\n  }\n\n  const text = `${value}`.trim()\n  if (!text) return {}\n  if (text === 'auto' || text === 'grow') return { base: text }\n  if (BARE_NUMBER.test(text)) return { base: Number(text) }\n\n  const pairs = text.split(/[\\s,]+/).filter(Boolean)\n  const values: Partial<Record<SpanBreakpoint, SpanValue>> = {}\n  for (const pair of pairs) {\n    const match = PAIR.exec(pair)\n    if (!match) return { raw: text }\n    const key = (match[1] ?? '').toLowerCase()\n    if (!isBreakpoint(key)) return { raw: text }\n    const span = match[2] ?? ''\n    values[key] =\n      span === 'auto' || span === 'grow' ? (span as SpanValue) : Number(span)\n  }\n  if (!Object.keys(values).length) return { raw: text }\n\n  // Normalized to breakpoint order so the serialized string is stable no\n  // matter what order the author wrote the pairs in.\n  const ordered: Partial<Record<SpanBreakpoint, SpanValue>> = {}\n  for (const key of SPAN_BREAKPOINTS) {\n    if (values[key] !== undefined) ordered[key] = values[key]\n  }\n  return { values: ordered }\n}\n\n/**\n * Serializes a {@link BreakpointSpan} back to the single string that gets\n * persisted. The inverse of {@link parseBreakpointSpan}: an empty span\n * serializes to an empty string, never to a partial pair like `md:`.\n */\nexport function buildBreakpointSpan(span?: BreakpointSpan): string {\n  if (!span) return ''\n  if (span.raw !== undefined) return span.raw\n  if (span.base !== undefined) return `${span.base}`\n  const values = span.values\n  if (!values) return ''\n  const pairs: string[] = []\n  for (const key of SPAN_BREAKPOINTS) {\n    const value = values[key]\n    if (value === undefined || value === null || (value as unknown) === '') {\n      continue\n    }\n    pairs.push(`${key}:${value}`)\n  }\n  return pairs.join(' ')\n}\n"],"names":["SPAN_BREAKPOINTS","BARE_NUMBER","PAIR","isBreakpoint","key","includes","parseBreakpointSpan","value","undefined","Number","isFinite","base","text","trim","test","pairs","split","filter","Boolean","values","pair","match","exec","raw","toLowerCase","span","Object","keys","length","ordered","buildBreakpointSpan","push","join"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAED;;;;;;;;;;;;;;;;;;CAkBC,GAED,qEAAqE,GACrE,OAAO,MAAMA,mBAAmB;IAAC;IAAM;IAAM;IAAM;IAAM;CAAK,CAAS;AAoBvE,qEAAqE,GACrE,MAAMC,cAAc;AACpB,0EAA0E,GAC1E,MAAMC,OAAO;AAEb,MAAMC,eAAe,CAACC,MACpB,AAACJ,iBAAuCK,QAAQ,CAACD;AAEnD;;;;;;CAMC,GACD,OAAO,SAASE,oBACdC,KAAyC;IAEzC,sEAAsE;IACtE,wEAAwE;IACxE,mDAAmD;IACnD,IAAIA,UAAUC,aAAaD,UAAU,QAAQA,UAAU,IAAI,OAAO,CAAC;IACnE,IAAI,OAAOA,UAAU,UAAU;QAC7B,OAAOE,OAAOC,QAAQ,CAACH,SAAS;YAAEI,MAAMJ;QAAM,IAAI,CAAC;IACrD;IAEA,MAAMK,OAAO,GAAGL,OAAO,CAACM,IAAI;IAC5B,IAAI,CAACD,MAAM,OAAO,CAAC;IACnB,IAAIA,SAAS,UAAUA,SAAS,QAAQ,OAAO;QAAED,MAAMC;IAAK;IAC5D,IAAIX,YAAYa,IAAI,CAACF,OAAO,OAAO;QAAED,MAAMF,OAAOG;IAAM;IAExD,MAAMG,QAAQH,KAAKI,KAAK,CAAC,UAAUC,MAAM,CAACC;IAC1C,MAAMC,SAAqD,CAAC;IAC5D,KAAK,MAAMC,QAAQL,MAAO;YAGXM,SAEAA;QAJb,MAAMA,QAAQnB,KAAKoB,IAAI,CAACF;QACxB,IAAI,CAACC,OAAO,OAAO;YAAEE,KAAKX;QAAK;QAC/B,MAAMR,MAAM,EAACiB,UAAAA,KAAK,CAAC,EAAE,YAARA,UAAY,IAAIG,WAAW;QACxC,IAAI,CAACrB,aAAaC,MAAM,OAAO;YAAEmB,KAAKX;QAAK;QAC3C,MAAMa,QAAOJ,WAAAA,KAAK,CAAC,EAAE,YAARA,WAAY;QACzBF,MAAM,CAACf,IAAI,GACTqB,SAAS,UAAUA,SAAS,SAAUA,OAAqBhB,OAAOgB;IACtE;IACA,IAAI,CAACC,OAAOC,IAAI,CAACR,QAAQS,MAAM,EAAE,OAAO;QAAEL,KAAKX;IAAK;IAEpD,uEAAuE;IACvE,mDAAmD;IACnD,MAAMiB,UAAsD,CAAC;IAC7D,KAAK,MAAMzB,OAAOJ,iBAAkB;QAClC,IAAImB,MAAM,CAACf,IAAI,KAAKI,WAAWqB,OAAO,CAACzB,IAAI,GAAGe,MAAM,CAACf,IAAI;IAC3D;IACA,OAAO;QAAEe,QAAQU;IAAQ;AAC3B;AAEA;;;;CAIC,GACD,OAAO,SAASC,oBAAoBL,IAAqB;IACvD,IAAI,CAACA,MAAM,OAAO;IAClB,IAAIA,KAAKF,GAAG,KAAKf,WAAW,OAAOiB,KAAKF,GAAG;IAC3C,IAAIE,KAAKd,IAAI,KAAKH,WAAW,OAAO,GAAGiB,KAAKd,IAAI,EAAE;IAClD,MAAMQ,SAASM,KAAKN,MAAM;IAC1B,IAAI,CAACA,QAAQ,OAAO;IACpB,MAAMJ,QAAkB,EAAE;IAC1B,KAAK,MAAMX,OAAOJ,iBAAkB;QAClC,MAAMO,QAAQY,MAAM,CAACf,IAAI;QACzB,IAAIG,UAAUC,aAAaD,UAAU,QAAQ,AAACA,UAAsB,IAAI;YACtE;QACF;QACAQ,MAAMgB,IAAI,CAAC,GAAG3B,IAAI,CAAC,EAAEG,OAAO;IAC9B;IACA,OAAOQ,MAAMiB,IAAI,CAAC;AACpB"}

package/src/lib/data-table.d.ts

@@ -0,0 +1,107 @@
+/**
+ * @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.
+ */
+/**
+ * The grid behind the Table element (AGL-2543).
+ *
+ * ONE parser, shared by the renderer and the attributes-panel editor. Two
+ * implementations of "what does this string mean" is how a table comes to
+ * look right in the canvas and wrong on the page, and the two are written by
+ * different people months apart.
+ *
+ * The persisted prop is a single string, following the house pattern used by
+ * `CSS_DIMENSION` and `CSS_GRADIENT`: the rich editor is an input affordance,
+ * not a shape change, so nothing downstream has to learn a new type and a
+ * value the editor cannot model is never clobbered.
+ *
+ * Pipe-delimited, one row per line — deliberately the markdown table body's
+ * own syntax, so the comparison tables already authored in Markdown elements
+ * paste straight in. A leading and trailing pipe are optional, which is what
+ * a copied markdown table has.
+ */
+/** Column alignments the editor offers and the renderer honours. */
+export declare const DATA_TABLE_ALIGNMENTS: readonly ["left", "center", "right"];
+export type DataTableAlignment = (typeof DATA_TABLE_ALIGNMENTS)[number];
+export declare const DATA_TABLE_ALIGNMENT_DEFAULT: DataTableAlignment;
+/**
+ * The alignments a pasted markdown divider row encodes, or `null` when the
+ * line is not one. `:--` is left, `:-:` centre, `--:` right.
+ */
+export declare function alignmentsFromDivider(line: string): DataTableAlignment[] | null;
+/**
+ * The grid a stored value describes.
+ *
+ * Rows are padded to the widest one so the renderer and the editor always see
+ * a rectangle: a short row is an authoring accident, and a table that renders
+ * with a missing cell is harder to fix than one with an empty one.
+ */
+export declare function parseDataTableRows(value: unknown): string[][];
+/**
+ * The alignments a stored value carries, padded to the table's width.
+ *
+ * Alignment lives in the SAME string as the grid, as a markdown divider row,
+ * rather than in a prop of its own. A field editor is handed one prop, so a
+ * second prop could not be reached from the grid's own per-column controls —
+ * and encoding it the way markdown already does means a pasted table keeps
+ * the alignment it was authored with instead of silently flattening to left.
+ */
+export declare function readDataTableAlignments(value: unknown, columnCount: number): DataTableAlignment[];
+/** A row of a table the author pasted, and the alignments it carried. */
+export interface PastedDataTable {
+    rows: string[][];
+    alignments: DataTableAlignment[];
+}
+/**
+ * The table a pasted string describes, or `null` when it is not one
+ * (AGL-2568).
+ *
+ * Reading it is the migration path off the Markdown workaround: the tables
+ * this element replaces are already authored as pipe syntax, and the
+ * alternative to importing them is retyping thirty cells of dated competitor
+ * pricing by hand, which is the content least safe to retype.
+ *
+ * `null` rather than a best effort is the important half. This runs on every
+ * paste into every cell, and an author pasting `Pro | Business` as a cell
+ * VALUE must get those characters, not a two-column table. So a paste is only
+ * read as a table when it could not sensibly be anything else: more than one
+ * line, every one of them carrying an unescaped pipe, and at least two
+ * columns once parsed. A single line never qualifies, however many pipes it
+ * has.
+ */
+export declare function readPastedDataTable(value: unknown): PastedDataTable | null;
+/**
+ * The stored form of a grid plus its alignments.
+ *
+ * The divider is written after the first row, where markdown puts it, and
+ * only when some column is not the default — an all-left table stays a plain
+ * pipe grid rather than growing a row of dashes nobody asked for.
+ */
+export declare function serializeDataTable(rows: string[][], alignments?: readonly DataTableAlignment[]): string;
+/**
+ * The 1-based column to emphasise, or `0` for none.
+ *
+ * 1-based because the control says "column 3" to an author who is looking at
+ * the third column; `0` rather than `null` so "none" survives a form field
+ * that only speaks numbers. Out-of-range values mean none, so deleting a
+ * column cannot leave a table pointing at one that is gone.
+ */
+export declare function normalizeEmphasisColumn(value: unknown, columnCount: number): number;
+/** A grid with `count` empty columns appended to every row. */
+export declare function withColumnAdded(rows: string[][], at?: number): string[][];
+export declare function withColumnRemoved(rows: string[][], at: number): string[][];
+export declare function withRowAdded(rows: string[][], at?: number): string[][];
+export declare function withRowRemoved(rows: string[][], at: number): string[][];
+export declare function withCellSet(rows: string[][], rowIndex: number, columnIndex: number, value: string): string[][];

package/src/lib/data-table.js

@@ -0,0 +1,225 @@
+/**
+ * @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.
+ */ /**
+ * The grid behind the Table element (AGL-2543).
+ *
+ * ONE parser, shared by the renderer and the attributes-panel editor. Two
+ * implementations of "what does this string mean" is how a table comes to
+ * look right in the canvas and wrong on the page, and the two are written by
+ * different people months apart.
+ *
+ * The persisted prop is a single string, following the house pattern used by
+ * `CSS_DIMENSION` and `CSS_GRADIENT`: the rich editor is an input affordance,
+ * not a shape change, so nothing downstream has to learn a new type and a
+ * value the editor cannot model is never clobbered.
+ *
+ * Pipe-delimited, one row per line — deliberately the markdown table body's
+ * own syntax, so the comparison tables already authored in Markdown elements
+ * paste straight in. A leading and trailing pipe are optional, which is what
+ * a copied markdown table has.
+ */ /** Column alignments the editor offers and the renderer honours. */ export const DATA_TABLE_ALIGNMENTS = [
+    'left',
+    'center',
+    'right'
+];
+export const DATA_TABLE_ALIGNMENT_DEFAULT = 'left';
+/**
+ * A markdown alignment divider — `|---|:--:|---:|`.
+ *
+ * Dropped rather than rendered as a row of dashes. It carries no content, and
+ * an author pasting a markdown table has no reason to expect it to survive as
+ * data; its alignment intent is read out separately by
+ * {@link alignmentsFromDivider}.
+ */ const DIVIDER_CELL = /^:?-{2,}:?$/;
+function splitRow(line) {
+    // `\|` is a literal pipe, so a cell may contain one. Split on unescaped
+    // pipes only, then unescape — doing it in the other order would turn an
+    // escaped pipe into a column break.
+    const cells = line.replace(/^\s*\|/, '').replace(/\|\s*$/, '').split(/(?<!\\)\|/).map((cell)=>cell.replace(/\\\|/g, '|').trim());
+    return cells;
+}
+function isDividerRow(cells) {
+    return cells.length > 0 && cells.every((cell)=>DIVIDER_CELL.test(cell));
+}
+/**
+ * The alignments a pasted markdown divider row encodes, or `null` when the
+ * line is not one. `:--` is left, `:-:` centre, `--:` right.
+ */ export function alignmentsFromDivider(line) {
+    const cells = splitRow(String(line != null ? line : ''));
+    if (!isDividerRow(cells)) return null;
+    return cells.map((cell)=>{
+        const left = cell.startsWith(':');
+        const right = cell.endsWith(':');
+        if (left && right) return 'center';
+        if (right) return 'right';
+        return 'left';
+    });
+}
+/**
+ * The grid a stored value describes.
+ *
+ * Rows are padded to the widest one so the renderer and the editor always see
+ * a rectangle: a short row is an authoring accident, and a table that renders
+ * with a missing cell is harder to fix than one with an empty one.
+ */ export function parseDataTableRows(value) {
+    const text = typeof value === 'string' ? value : '';
+    const rows = text.split(/\r?\n/).map((line)=>line.trim()).filter((line)=>line.length > 0).map(splitRow).filter((cells)=>!isDividerRow(cells));
+    const width = rows.reduce((widest, row)=>Math.max(widest, row.length), 0);
+    return rows.map((row)=>[
+            ...row,
+            ...Array.from({
+                length: width - row.length
+            }, ()=>'')
+        ]);
+}
+/**
+ * The alignments a stored value carries, padded to the table's width.
+ *
+ * Alignment lives in the SAME string as the grid, as a markdown divider row,
+ * rather than in a prop of its own. A field editor is handed one prop, so a
+ * second prop could not be reached from the grid's own per-column controls —
+ * and encoding it the way markdown already does means a pasted table keeps
+ * the alignment it was authored with instead of silently flattening to left.
+ */ export function readDataTableAlignments(value, columnCount) {
+    const found = String(value != null ? value : '').split(/\r?\n/).map((line)=>alignmentsFromDivider(line)).find((alignments)=>alignments !== null);
+    return Array.from({
+        length: Math.max(0, columnCount)
+    }, (_, index)=>{
+        const candidate = found == null ? void 0 : found[index];
+        return candidate != null ? candidate : DATA_TABLE_ALIGNMENT_DEFAULT;
+    });
+}
+/** A pipe that breaks a column, as opposed to a `\|` inside a cell. */ function hasUnescapedPipe(line) {
+    return /(?<!\\)\|/.test(line);
+}
+/**
+ * The table a pasted string describes, or `null` when it is not one
+ * (AGL-2568).
+ *
+ * Reading it is the migration path off the Markdown workaround: the tables
+ * this element replaces are already authored as pipe syntax, and the
+ * alternative to importing them is retyping thirty cells of dated competitor
+ * pricing by hand, which is the content least safe to retype.
+ *
+ * `null` rather than a best effort is the important half. This runs on every
+ * paste into every cell, and an author pasting `Pro | Business` as a cell
+ * VALUE must get those characters, not a two-column table. So a paste is only
+ * read as a table when it could not sensibly be anything else: more than one
+ * line, every one of them carrying an unescaped pipe, and at least two
+ * columns once parsed. A single line never qualifies, however many pipes it
+ * has.
+ */ export function readPastedDataTable(value) {
+    var _ref;
+    var _rows_;
+    const text = typeof value === 'string' ? value : '';
+    const lines = text.split(/\r?\n/).map((line)=>line.trim()).filter((line)=>line.length > 0);
+    if (lines.length < 2 || !lines.every(hasUnescapedPipe)) return null;
+    const rows = parseDataTableRows(text);
+    const width = (_ref = (_rows_ = rows[0]) == null ? void 0 : _rows_.length) != null ? _ref : 0;
+    if (rows.length === 0 || width < 2) return null;
+    return {
+        rows,
+        alignments: readDataTableAlignments(text, width)
+    };
+}
+/** The markdown divider encoding one column's alignment. */ function dividerCell(alignment) {
+    if (alignment === 'center') return ':---:';
+    if (alignment === 'right') return '---:';
+    return '---';
+}
+/**
+ * The stored form of a grid plus its alignments.
+ *
+ * The divider is written after the first row, where markdown puts it, and
+ * only when some column is not the default — an all-left table stays a plain
+ * pipe grid rather than growing a row of dashes nobody asked for.
+ */ export function serializeDataTable(rows, alignments) {
+    var _ref, _ref1;
+    var _rows_;
+    const body = (rows != null ? rows : []).map((row)=>(row != null ? row : []).map((cell)=>String(cell != null ? cell : '').replace(/\|/g, '\\|')).join(' | '));
+    const meaningful = (_ref = alignments == null ? void 0 : alignments.some((alignment)=>alignment && alignment !== DATA_TABLE_ALIGNMENT_DEFAULT)) != null ? _ref : false;
+    if (!meaningful || body.length === 0) return body.join('\n');
+    const width = (_ref1 = (_rows_ = rows[0]) == null ? void 0 : _rows_.length) != null ? _ref1 : 0;
+    const divider = Array.from({
+        length: width
+    }, (_, index)=>{
+        var _ref;
+        return dividerCell((_ref = alignments == null ? void 0 : alignments[index]) != null ? _ref : DATA_TABLE_ALIGNMENT_DEFAULT);
+    }).join(' | ');
+    return [
+        body[0],
+        divider,
+        ...body.slice(1)
+    ].join('\n');
+}
+/**
+ * The 1-based column to emphasise, or `0` for none.
+ *
+ * 1-based because the control says "column 3" to an author who is looking at
+ * the third column; `0` rather than `null` so "none" survives a form field
+ * that only speaks numbers. Out-of-range values mean none, so deleting a
+ * column cannot leave a table pointing at one that is gone.
+ */ export function normalizeEmphasisColumn(value, columnCount) {
+    const parsed = Math.trunc(Number(value));
+    if (!Number.isFinite(parsed) || parsed < 1 || parsed > columnCount) return 0;
+    return parsed;
+}
+/** A grid with `count` empty columns appended to every row. */ export function withColumnAdded(rows, at) {
+    var _ref;
+    var _rows_;
+    const width = (_ref = (_rows_ = rows[0]) == null ? void 0 : _rows_.length) != null ? _ref : 0;
+    const index = at == null ? width : Math.max(0, Math.min(at, width));
+    return (rows.length ? rows : [
+        []
+    ]).map((row)=>{
+        const next = [
+            ...row
+        ];
+        next.splice(index, 0, '');
+        return next;
+    });
+}
+export function withColumnRemoved(rows, at) {
+    var _ref;
+    var _rows_;
+    const width = (_ref = (_rows_ = rows[0]) == null ? void 0 : _rows_.length) != null ? _ref : 0;
+    // Never leave a table with no columns: a zero-column grid cannot be typed
+    // back into through the editor, so the last column is not removable.
+    if (width <= 1) return rows;
+    return rows.map((row)=>row.filter((_, index)=>index !== at));
+}
+export function withRowAdded(rows, at) {
+    var _ref;
+    var _rows_;
+    const width = (_ref = (_rows_ = rows[0]) == null ? void 0 : _rows_.length) != null ? _ref : 1;
+    const blank = Array.from({
+        length: width
+    }, ()=>'');
+    const next = [
+        ...rows
+    ];
+    next.splice(at == null ? rows.length : Math.max(0, Math.min(at, rows.length)), 0, blank);
+    return next;
+}
+export function withRowRemoved(rows, at) {
+    if (rows.length <= 1) return rows;
+    return rows.filter((_, index)=>index !== at);
+}
+export function withCellSet(rows, rowIndex, columnIndex, value) {
+    return rows.map((row, r)=>r === rowIndex ? row.map((cell, c)=>c === columnIndex ? value : cell) : row);
+}
+
+//# sourceMappingURL=data-table.js.map

package/src/lib/data-table.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/shared/data/enums/src/lib/data-table.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 * The grid behind the Table element (AGL-2543).\n *\n * ONE parser, shared by the renderer and the attributes-panel editor. Two\n * implementations of \"what does this string mean\" is how a table comes to\n * look right in the canvas and wrong on the page, and the two are written by\n * different people months apart.\n *\n * The persisted prop is a single string, following the house pattern used by\n * `CSS_DIMENSION` and `CSS_GRADIENT`: the rich editor is an input affordance,\n * not a shape change, so nothing downstream has to learn a new type and a\n * value the editor cannot model is never clobbered.\n *\n * Pipe-delimited, one row per line — deliberately the markdown table body's\n * own syntax, so the comparison tables already authored in Markdown elements\n * paste straight in. A leading and trailing pipe are optional, which is what\n * a copied markdown table has.\n */\n\n/** Column alignments the editor offers and the renderer honours. */\nexport const DATA_TABLE_ALIGNMENTS = ['left', 'center', 'right'] as const\n\nexport type DataTableAlignment = (typeof DATA_TABLE_ALIGNMENTS)[number]\n\nexport const DATA_TABLE_ALIGNMENT_DEFAULT: DataTableAlignment = 'left'\n\n/**\n * A markdown alignment divider — `|---|:--:|---:|`.\n *\n * Dropped rather than rendered as a row of dashes. It carries no content, and\n * an author pasting a markdown table has no reason to expect it to survive as\n * data; its alignment intent is read out separately by\n * {@link alignmentsFromDivider}.\n */\nconst DIVIDER_CELL = /^:?-{2,}:?$/\n\nfunction splitRow(line: string): string[] {\n  // `\\|` is a literal pipe, so a cell may contain one. Split on unescaped\n  // pipes only, then unescape — doing it in the other order would turn an\n  // escaped pipe into a column break.\n  const cells = line\n    .replace(/^\\s*\\|/, '')\n    .replace(/\\|\\s*$/, '')\n    .split(/(?<!\\\\)\\|/)\n    .map((cell) => cell.replace(/\\\\\\|/g, '|').trim())\n  return cells\n}\n\nfunction isDividerRow(cells: string[]): boolean {\n  return cells.length > 0 && cells.every((cell) => DIVIDER_CELL.test(cell))\n}\n\n/**\n * The alignments a pasted markdown divider row encodes, or `null` when the\n * line is not one. `:--` is left, `:-:` centre, `--:` right.\n */\nexport function alignmentsFromDivider(\n  line: string,\n): DataTableAlignment[] | null {\n  const cells = splitRow(String(line ?? ''))\n  if (!isDividerRow(cells)) return null\n  return cells.map((cell) => {\n    const left = cell.startsWith(':')\n    const right = cell.endsWith(':')\n    if (left && right) return 'center'\n    if (right) return 'right'\n    return 'left'\n  })\n}\n\n/**\n * The grid a stored value describes.\n *\n * Rows are padded to the widest one so the renderer and the editor always see\n * a rectangle: a short row is an authoring accident, and a table that renders\n * with a missing cell is harder to fix than one with an empty one.\n */\nexport function parseDataTableRows(value: unknown): string[][] {\n  const text = typeof value === 'string' ? value : ''\n  const rows = text\n    .split(/\\r?\\n/)\n    .map((line) => line.trim())\n    .filter((line) => line.length > 0)\n    .map(splitRow)\n    .filter((cells) => !isDividerRow(cells))\n  const width = rows.reduce((widest, row) => Math.max(widest, row.length), 0)\n  return rows.map((row) => [\n    ...row,\n    ...Array.from({ length: width - row.length }, () => ''),\n  ])\n}\n\n/**\n * The alignments a stored value carries, padded to the table's width.\n *\n * Alignment lives in the SAME string as the grid, as a markdown divider row,\n * rather than in a prop of its own. A field editor is handed one prop, so a\n * second prop could not be reached from the grid's own per-column controls —\n * and encoding it the way markdown already does means a pasted table keeps\n * the alignment it was authored with instead of silently flattening to left.\n */\nexport function readDataTableAlignments(\n  value: unknown,\n  columnCount: number,\n): DataTableAlignment[] {\n  const found = String(value ?? '')\n    .split(/\\r?\\n/)\n    .map((line) => alignmentsFromDivider(line))\n    .find((alignments) => alignments !== null)\n  return Array.from({ length: Math.max(0, columnCount) }, (_, index) => {\n    const candidate = found?.[index]\n    return candidate ?? DATA_TABLE_ALIGNMENT_DEFAULT\n  })\n}\n\n/** A row of a table the author pasted, and the alignments it carried. */\nexport interface PastedDataTable {\n  rows: string[][]\n  alignments: DataTableAlignment[]\n}\n\n/** A pipe that breaks a column, as opposed to a `\\|` inside a cell. */\nfunction hasUnescapedPipe(line: string): boolean {\n  return /(?<!\\\\)\\|/.test(line)\n}\n\n/**\n * The table a pasted string describes, or `null` when it is not one\n * (AGL-2568).\n *\n * Reading it is the migration path off the Markdown workaround: the tables\n * this element replaces are already authored as pipe syntax, and the\n * alternative to importing them is retyping thirty cells of dated competitor\n * pricing by hand, which is the content least safe to retype.\n *\n * `null` rather than a best effort is the important half. This runs on every\n * paste into every cell, and an author pasting `Pro | Business` as a cell\n * VALUE must get those characters, not a two-column table. So a paste is only\n * read as a table when it could not sensibly be anything else: more than one\n * line, every one of them carrying an unescaped pipe, and at least two\n * columns once parsed. A single line never qualifies, however many pipes it\n * has.\n */\nexport function readPastedDataTable(value: unknown): PastedDataTable | null {\n  const text = typeof value === 'string' ? value : ''\n  const lines = text\n    .split(/\\r?\\n/)\n    .map((line) => line.trim())\n    .filter((line) => line.length > 0)\n  if (lines.length < 2 || !lines.every(hasUnescapedPipe)) return null\n  const rows = parseDataTableRows(text)\n  const width = rows[0]?.length ?? 0\n  if (rows.length === 0 || width < 2) return null\n  return { rows, alignments: readDataTableAlignments(text, width) }\n}\n\n/** The markdown divider encoding one column's alignment. */\nfunction dividerCell(alignment: DataTableAlignment): string {\n  if (alignment === 'center') return ':---:'\n  if (alignment === 'right') return '---:'\n  return '---'\n}\n\n/**\n * The stored form of a grid plus its alignments.\n *\n * The divider is written after the first row, where markdown puts it, and\n * only when some column is not the default — an all-left table stays a plain\n * pipe grid rather than growing a row of dashes nobody asked for.\n */\nexport function serializeDataTable(\n  rows: string[][],\n  alignments?: readonly DataTableAlignment[],\n): string {\n  const body = (rows ?? []).map((row) =>\n    (row ?? [])\n      .map((cell) => String(cell ?? '').replace(/\\|/g, '\\\\|'))\n      .join(' | '),\n  )\n  const meaningful =\n    alignments?.some(\n      (alignment) => alignment && alignment !== DATA_TABLE_ALIGNMENT_DEFAULT,\n    ) ?? false\n  if (!meaningful || body.length === 0) return body.join('\\n')\n  const width = rows[0]?.length ?? 0\n  const divider = Array.from({ length: width }, (_, index) =>\n    dividerCell(alignments?.[index] ?? DATA_TABLE_ALIGNMENT_DEFAULT),\n  ).join(' | ')\n  return [body[0], divider, ...body.slice(1)].join('\\n')\n}\n\n/**\n * The 1-based column to emphasise, or `0` for none.\n *\n * 1-based because the control says \"column 3\" to an author who is looking at\n * the third column; `0` rather than `null` so \"none\" survives a form field\n * that only speaks numbers. Out-of-range values mean none, so deleting a\n * column cannot leave a table pointing at one that is gone.\n */\nexport function normalizeEmphasisColumn(\n  value: unknown,\n  columnCount: number,\n): number {\n  const parsed = Math.trunc(Number(value))\n  if (!Number.isFinite(parsed) || parsed < 1 || parsed > columnCount) return 0\n  return parsed\n}\n\n/** A grid with `count` empty columns appended to every row. */\nexport function withColumnAdded(rows: string[][], at?: number): string[][] {\n  const width = rows[0]?.length ?? 0\n  const index = at == null ? width : Math.max(0, Math.min(at, width))\n  return (rows.length ? rows : [[]]).map((row) => {\n    const next = [...row]\n    next.splice(index, 0, '')\n    return next\n  })\n}\n\nexport function withColumnRemoved(rows: string[][], at: number): string[][] {\n  const width = rows[0]?.length ?? 0\n  // Never leave a table with no columns: a zero-column grid cannot be typed\n  // back into through the editor, so the last column is not removable.\n  if (width <= 1) return rows\n  return rows.map((row) => row.filter((_, index) => index !== at))\n}\n\nexport function withRowAdded(rows: string[][], at?: number): string[][] {\n  const width = rows[0]?.length ?? 1\n  const blank = Array.from({ length: width }, () => '')\n  const next = [...rows]\n  next.splice(at == null ? rows.length : Math.max(0, Math.min(at, rows.length)), 0, blank)\n  return next\n}\n\nexport function withRowRemoved(rows: string[][], at: number): string[][] {\n  if (rows.length <= 1) return rows\n  return rows.filter((_, index) => index !== at)\n}\n\nexport function withCellSet(\n  rows: string[][],\n  rowIndex: number,\n  columnIndex: number,\n  value: string,\n): string[][] {\n  return rows.map((row, r) =>\n    r === rowIndex\n      ? row.map((cell, c) => (c === columnIndex ? value : cell))\n      : row,\n  )\n}\n"],"names":["DATA_TABLE_ALIGNMENTS","DATA_TABLE_ALIGNMENT_DEFAULT","DIVIDER_CELL","splitRow","line","cells","replace","split","map","cell","trim","isDividerRow","length","every","test","alignmentsFromDivider","String","left","startsWith","right","endsWith","parseDataTableRows","value","text","rows","filter","width","reduce","widest","row","Math","max","Array","from","readDataTableAlignments","columnCount","found","find","alignments","_","index","candidate","hasUnescapedPipe","readPastedDataTable","lines","dividerCell","alignment","serializeDataTable","body","join","meaningful","some","divider","slice","normalizeEmphasisColumn","parsed","trunc","Number","isFinite","withColumnAdded","at","min","next","splice","withColumnRemoved","withRowAdded","blank","withRowRemoved","withCellSet","rowIndex","columnIndex","r","c"],"mappings":"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"}

package/src/lib/firebase-auth.d.ts

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * Copyright 2023 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.
+ */
+import { type AuthError, AuthErrorCodes, type OAuthCredential, type UserCredential } from 'firebase/auth';
+export declare const AuthAppErrorCodes: {
+    /** Google resolved SSO against the wrong signed-in account. */
+    readonly SSO_ACCOUNT_MISMATCH: "auth/sso-account-mismatch";
+    /** No SSO configured for the email domain the user typed. */
+    readonly SSO_NOT_CONFIGURED: "auth/sso-not-configured";
+    /** The user submitted the SSO gate without a usable email. */
+    readonly SSO_INPUT_REQUIRED: "auth/sso-input-required";
+    /** Authenticated with the IdP, but not a member of the organization. */
+    readonly SSO_NOT_AUTHORIZED: "auth/sso-not-authorized";
+    /**
+     * The IdP window closed without a result. On the SSO path this is NOT the
+     * plain cancel it is elsewhere: when Google refuses the SAML request it
+     * renders its own error page inside that window, so the user closing it
+     * looks identical to a cancel. Suppressing it — as the shared
+     * `AuthErrorIgnore` list does for popup-closed — is what left the desktop
+     * flow with Google's raw error and nothing from us.
+     */
+    readonly SSO_INCOMPLETE: "auth/sso-incomplete";
+    /** SSO failed for a reason we could not classify. */
+    readonly SSO_FAILED: "auth/sso-failed";
+    /**
+     * The WebAuthn ceremony ended without an assertion (AGL-1417).
+     *
+     * Deliberately NOT called "cancelled". The spec overloads
+     * `NotAllowedError` to cover a dismissed prompt, a timeout, AND no
+     * discoverable credential for the RP ID — the last on purpose, so a site
+     * cannot probe for a credential's existence. Naming this "cancelled" is
+     * what let "you have no passkey on this device" render as nothing at all.
+     */
+    readonly PASSKEY_NOT_COMPLETED: "auth/passkey-not-completed";
+    /** The ceremony ran but the server refused the assertion. */
+    readonly PASSKEY_SIGNIN_FAILED: "auth/passkey-signin-failed";
+};
+export type AuthAppCode = (typeof AuthAppErrorCodes)[keyof typeof AuthAppErrorCodes];
+export type AuthCode = IndexOf<typeof AuthErrorCodes> | AuthAppCode | 'general';
+export type AuthResultError = AuthError;
+export type AuthResultUser = UserCredential & {
+    credential?: OAuthCredential;
+};
+export type AuthCallbackResult = Promise<UserCredential>;
+export declare const AuthErrorIgnore: {
+    "auth/user-cancelled": boolean;
+    "auth/redirect-cancelled-by-user": boolean;
+    "auth/popup-closed-by-user": boolean;
+};
+export declare const AuthErrorNotice: {
+    "auth/user-signed-out": boolean;
+    "auth/requires-recent-login": boolean;
+    "auth/sso-account-mismatch": boolean;
+    "auth/sso-not-configured": boolean;
+    "auth/sso-input-required": boolean;
+    "auth/sso-incomplete": boolean;
+    "auth/passkey-not-completed": boolean;
+};
+export declare const AuthErrorMessage: Partial<Record<AuthCode, string>>;
+export declare const COOKIE_KEY_USER_TOKEN = "aglyn-user-token";