vastgrid 0.1.0 → 0.2.0

package/dist/core/filters.js

@@ -0,0 +1,303 @@
+/**
+ * The filter of one column as the column menu edits it: values ticked in a list, or a condition. Each is written
+ * as the parts of `where` that `filter.column` sets (§6.2.1 of the specification), and read back from them.
+ */
+import { columnsOf, joinParts, partsOf, readCellText } from "vastgrid-spec";
+const ORDERED = ["eq", "ne", "gt", "ge", "lt", "le", "between", "blank", "notBlank"];
+const TEXT = ["contains", "notContains", "startsWith", "endsWith", "eq", "ne", "blank", "notBlank"];
+
+/** The operators offered for a column's type. */
+export function operatorsFor(type) {
+  if (type === "string") return TEXT;
+  if (type === "boolean" || type === "binary" || type === "interval") return ["blank", "notBlank"];
+  if (type === "uuid") return ["eq", "ne", "blank", "notBlank"];
+  return ORDERED;
+}
+
+/** Whether an operator takes no text. */
+export function takesNoValue(operator) {
+  return operator === "blank" || operator === "notBlank";
+}
+
+/** A literal of a value of a column (§2.5): values that JSON writes as strings carry the column's type. */
+function literalOf(value, column) {
+  if (typeof value === "string" && column.type !== "string") return {
+    lit: value,
+    type: column.type
+  };
+  return {
+    lit: value
+  };
+}
+function call(fn, ...args) {
+  return {
+    fn,
+    args
+  };
+}
+
+/** Rows for which `expr` is not true: null counts as not matching, so `not` keeps the rows where it is null. */
+function notMatching(expr) {
+  return call("not", call("coalesce", expr, {
+    lit: false
+  }));
+}
+const TEXT_FUNCTIONS = {
+  contains: "contains",
+  notContains: "contains",
+  startsWith: "starts_with",
+  endsWith: "ends_with"
+};
+export class FilterTextError extends Error {
+  constructor(side) {
+    super(`The ${side} value is not a value of the column.`);
+    this.side = side;
+  }
+}
+
+/**
+ * The parts of `where` for a column's filter; none when it keeps every row. Text that is not a value of the column
+ * throws a `FilterTextError` (§7.3 reads it as a cell's text is read).
+ */
+export function filterParts(filter, column) {
+  const c = {
+    col: column.name
+  };
+  if (filter.kind === "values") {
+    const parts = [];
+    if (filter.values.length > 0) parts.push(call("in", c, ...filter.values.map(value => literalOf(value, column))));
+    if (filter.blank) parts.push(call("is_blank", c));
+    const matching = parts.length === 0 ? null : parts.length === 1 ? parts[0] : call("or", ...parts);
+    if (filter.exclude) return matching ? [notMatching(matching)] : [];
+    return [matching ?? {
+      lit: false
+    }];
+  }
+  const {
+    operator
+  } = filter;
+  if (operator === "blank") return [call("is_blank", c)];
+  if (operator === "notBlank") return [call("not", call("is_blank", c))];
+  const text = TEXT_FUNCTIONS[operator];
+  if (text) {
+    if (filter.first === "") return [];
+    const expr = call(text, call("lower", call("text", c)), call("lower", {
+      lit: filter.first
+    }));
+    return [operator === "notContains" ? notMatching(expr) : expr];
+  }
+  const read = (input, side) => {
+    if (input.trim() === "") return null;
+    const result = readCellText(input, column, {
+      grouping: true
+    });
+    if (!result.ok || result.value === null) throw new FilterTextError(side);
+    return literalOf(result.value, column);
+  };
+  if (operator === "between") {
+    const low = read(filter.first, "first");
+    const high = read(filter.second, "second");
+    return [...(low ? [call("ge", c, low)] : []), ...(high ? [call("le", c, high)] : [])];
+  }
+  const value = read(filter.first, "first");
+  return value ? [call(operator, c, value)] : [];
+}
+function isColumn(expr, name) {
+  return expr !== undefined && "col" in expr && expr.col === name;
+}
+function isLiteral(expr) {
+  return expr !== undefined && "lit" in expr;
+}
+function isCall(expr, fn) {
+  return expr !== undefined && "fn" in expr && expr.fn === fn;
+}
+
+/** The text of a literal as the menu shows it to edit. */
+function literalText(literal) {
+  return literal.lit === null ? "" : String(literal.lit);
+}
+
+/** `in(c, …)`, `is_blank(c)` or the `or` of both, as values. */
+function readValues(expr, name) {
+  const parts = isCall(expr, "or") ? expr.args : [expr];
+  let values = null;
+  let blank = false;
+  for (const part of parts) {
+    if (isCall(part, "in") && isColumn(part.args[0], name) && values === null && part.args.slice(1).every(isLiteral)) {
+      values = part.args.slice(1).map(literal => literal.lit);
+    } else if (isCall(part, "is_blank") && isColumn(part.args[0], name) && !blank) {
+      blank = true;
+    } else {
+      return null;
+    }
+  }
+  return {
+    values: values ?? [],
+    blank
+  };
+}
+
+/** `contains(lower(text(c)), lower(lit))` and the like: the operator and the text. */
+function readText(expr, name) {
+  if (!("fn" in expr) || !["contains", "starts_with", "ends_with"].includes(expr.fn)) return null;
+  const [haystack, needle] = expr.args;
+  if (!isCall(haystack, "lower") || !isCall(haystack.args[0], "text") || !isColumn(haystack.args[0].args[0], name)) {
+    return null;
+  }
+  if (!isCall(needle, "lower") || !isLiteral(needle.args[0]) || typeof needle.args[0].lit !== "string") return null;
+  return {
+    fn: expr.fn,
+    text: needle.args[0].lit
+  };
+}
+const COMPARISONS = ["eq", "ne", "lt", "le", "gt", "ge"];
+
+/**
+ * The filter that the conditions of a column (§6.2.1) make, when the menu wrote them or they have the same shape;
+ * null when there are none, and `"other"` for conditions written otherwise (an agent, a saved view).
+ */
+export function readFilter(parts, name) {
+  if (parts.length === 0) return null;
+  if (parts.length === 2) {
+    const [low, high] = parts;
+    if (isCall(low, "ge") && isCall(high, "le") && isColumn(low.args[0], name) && isColumn(high.args[0], name) && isLiteral(low.args[1]) && isLiteral(high.args[1])) {
+      return {
+        kind: "condition",
+        operator: "between",
+        first: literalText(low.args[1]),
+        second: literalText(high.args[1])
+      };
+    }
+    return "other";
+  }
+  if (parts.length !== 1) return "other";
+  const [part] = parts;
+  if (isLiteral(part) && part.lit === false) return {
+    kind: "values",
+    values: [],
+    blank: false,
+    exclude: false
+  };
+  if (isCall(part, "is_blank") && isColumn(part.args[0], name)) {
+    return {
+      kind: "condition",
+      operator: "blank",
+      first: "",
+      second: ""
+    };
+  }
+  if (isCall(part, "not")) {
+    const inner = part.args[0];
+    if (isCall(inner, "is_blank") && isColumn(inner.args[0], name)) {
+      return {
+        kind: "condition",
+        operator: "notBlank",
+        first: "",
+        second: ""
+      };
+    }
+    if (isCall(inner, "coalesce") && isLiteral(inner.args[1]) && inner.args[1].lit === false) {
+      const matching = inner.args[0];
+      const values = readValues(matching, name);
+      if (values) return {
+        kind: "values",
+        ...values,
+        exclude: true
+      };
+      const text = readText(matching, name);
+      if (text?.fn === "contains") return {
+        kind: "condition",
+        operator: "notContains",
+        first: text.text,
+        second: ""
+      };
+    }
+    return "other";
+  }
+  const values = readValues(part, name);
+  if (values && values.values.length > 0) return {
+    kind: "values",
+    ...values,
+    exclude: false
+  };
+  const text = readText(part, name);
+  if (text) {
+    const operator = text.fn === "contains" ? "contains" : text.fn === "starts_with" ? "startsWith" : "endsWith";
+    return {
+      kind: "condition",
+      operator,
+      first: text.text,
+      second: ""
+    };
+  }
+  const comparison = COMPARISONS.find(fn => isCall(part, fn));
+  if (comparison && isCall(part, comparison)) {
+    const [left, right] = part.args;
+    // One side of a range is read as the comparison it is.
+    if (isColumn(left, name) && isLiteral(right)) {
+      return {
+        kind: "condition",
+        operator: comparison,
+        first: literalText(right),
+        second: ""
+      };
+    }
+  }
+  return "other";
+}
+
+/** The conditions of a column (§6.2.1): the parts of `where` that are not the search and refer to it and no other. */
+export function conditionsOf(where, name) {
+  return partsOf(where).filter(part => {
+    if ("search" in part) return false;
+    const names = columnsOf(part);
+    return names.size === 1 && names.has(name);
+  });
+}
+
+/**
+ * The plan whose rows are a column's values and how many rows have each, the most common first: the rows of
+ * `plan` without its conditions on the column (so that the list holds the values that other filters leave), and
+ * with those whose text contains `search`, ignoring letter case. Null when the plan groups rows.
+ */
+export function valuesPlan(plan, name, search) {
+  if (plan.aggregate) return null;
+  const own = new Set(conditionsOf(plan.where, name));
+  const parts = partsOf(plan.where).filter(part => !own.has(part));
+  if (search.trim() !== "") {
+    parts.push(call("contains", call("lower", call("text", {
+      col: name
+    })), call("lower", {
+      lit: search
+    })));
+  }
+  let count = "count";
+  for (let n = 2; count === name; n++) count = `count ${n}`;
+  const where = joinParts(parts);
+  return {
+    plan: {
+      ...(plan.derive ? {
+        derive: plan.derive
+      } : {}),
+      ...(where ? {
+        where
+      } : {}),
+      aggregate: {
+        keys: [name],
+        measures: [{
+          name: count,
+          fn: "count"
+        }]
+      },
+      sort: [{
+        column: count,
+        direction: "desc"
+      }, {
+        column: name,
+        direction: "asc"
+      }]
+    },
+    count
+  };
+}
+//# sourceMappingURL=filters.js.map

package/dist/core/filters.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["columnsOf","joinParts","partsOf","readCellText","ORDERED","TEXT","operatorsFor","type","takesNoValue","operator","literalOf","value","column","lit","call","fn","args","notMatching","expr","TEXT_FUNCTIONS","contains","notContains","startsWith","endsWith","FilterTextError","Error","constructor","side","filterParts","filter","c","col","name","kind","parts","values","length","push","map","blank","matching","exclude","text","first","read","input","trim","result","grouping","ok","low","high","second","isColumn","undefined","isLiteral","isCall","literalText","literal","String","readValues","part","slice","every","readText","includes","haystack","needle","COMPARISONS","readFilter","inner","comparison","find","left","right","conditionsOf","where","names","size","has","valuesPlan","plan","search","aggregate","own","Set","count","n","derive","keys","measures","sort","direction"],"sources":["filters.ts"],"sourcesContent":["/**\n * The filter of one column as the column menu edits it: values ticked in a list, or a condition. Each is written\n * as the parts of `where` that `filter.column` sets (§6.2.1 of the specification), and read back from them.\n */\nimport {\n  type Column,\n  columnsOf,\n  type Expr,\n  type FunctionName,\n  type JsonValue,\n  joinParts,\n  type Literal,\n  type LogicalType,\n  type Plan,\n  partsOf,\n  readCellText,\n} from \"vastgrid-spec\";\n\nexport type FilterOperator =\n  | \"eq\"\n  | \"ne\"\n  | \"lt\"\n  | \"le\"\n  | \"gt\"\n  | \"ge\"\n  | \"between\"\n  | \"contains\"\n  | \"notContains\"\n  | \"startsWith\"\n  | \"endsWith\"\n  | \"blank\"\n  | \"notBlank\";\n\nexport type ColumnFilter =\n  /** Rows with one of `values`, or blank (§3.2) with `blank`; with `exclude`, the other rows. */\n  | { kind: \"values\"; values: JsonValue[]; blank: boolean; exclude: boolean }\n  /** A condition on typed text: `first`, and `second` for `between`; an empty text leaves that side out. */\n  | { kind: \"condition\"; operator: FilterOperator; first: string; second: string };\n\nconst ORDERED: FilterOperator[] = [\"eq\", \"ne\", \"gt\", \"ge\", \"lt\", \"le\", \"between\", \"blank\", \"notBlank\"];\nconst TEXT: FilterOperator[] = [\"contains\", \"notContains\", \"startsWith\", \"endsWith\", \"eq\", \"ne\", \"blank\", \"notBlank\"];\n\n/** The operators offered for a column's type. */\nexport function operatorsFor(type: LogicalType): FilterOperator[] {\n  if (type === \"string\") return TEXT;\n  if (type === \"boolean\" || type === \"binary\" || type === \"interval\") return [\"blank\", \"notBlank\"];\n  if (type === \"uuid\") return [\"eq\", \"ne\", \"blank\", \"notBlank\"];\n  return ORDERED;\n}\n\n/** Whether an operator takes no text. */\nexport function takesNoValue(operator: FilterOperator) {\n  return operator === \"blank\" || operator === \"notBlank\";\n}\n\n/** A literal of a value of a column (§2.5): values that JSON writes as strings carry the column's type. */\nfunction literalOf(value: JsonValue, column: Column): Literal {\n  if (typeof value === \"string\" && column.type !== \"string\") return { lit: value, type: column.type };\n  return { lit: value };\n}\n\nfunction call(fn: FunctionName, ...args: Expr[]): Expr {\n  return { fn, args };\n}\n\n/** Rows for which `expr` is not true: null counts as not matching, so `not` keeps the rows where it is null. */\nfunction notMatching(expr: Expr): Expr {\n  return call(\"not\", call(\"coalesce\", expr, { lit: false }));\n}\n\nconst TEXT_FUNCTIONS: Partial<Record<FilterOperator, FunctionName>> = {\n  contains: \"contains\",\n  notContains: \"contains\",\n  startsWith: \"starts_with\",\n  endsWith: \"ends_with\",\n};\n\nexport class FilterTextError extends Error {\n  constructor(readonly side: \"first\" | \"second\") {\n    super(`The ${side} value is not a value of the column.`);\n  }\n}\n\n/**\n * The parts of `where` for a column's filter; none when it keeps every row. Text that is not a value of the column\n * throws a `FilterTextError` (§7.3 reads it as a cell's text is read).\n */\nexport function filterParts(filter: ColumnFilter, column: Column): Expr[] {\n  const c: Expr = { col: column.name };\n  if (filter.kind === \"values\") {\n    const parts: Expr[] = [];\n    if (filter.values.length > 0) parts.push(call(\"in\", c, ...filter.values.map((value) => literalOf(value, column))));\n    if (filter.blank) parts.push(call(\"is_blank\", c));\n    const matching = parts.length === 0 ? null : parts.length === 1 ? parts[0] : call(\"or\", ...parts);\n    if (filter.exclude) return matching ? [notMatching(matching)] : [];\n    return [matching ?? { lit: false }];\n  }\n  const { operator } = filter;\n  if (operator === \"blank\") return [call(\"is_blank\", c)];\n  if (operator === \"notBlank\") return [call(\"not\", call(\"is_blank\", c))];\n  const text = TEXT_FUNCTIONS[operator];\n  if (text) {\n    if (filter.first === \"\") return [];\n    const expr = call(text, call(\"lower\", call(\"text\", c)), call(\"lower\", { lit: filter.first }));\n    return [operator === \"notContains\" ? notMatching(expr) : expr];\n  }\n  const read = (input: string, side: \"first\" | \"second\") => {\n    if (input.trim() === \"\") return null;\n    const result = readCellText(input, column, { grouping: true });\n    if (!result.ok || result.value === null) throw new FilterTextError(side);\n    return literalOf(result.value, column);\n  };\n  if (operator === \"between\") {\n    const low = read(filter.first, \"first\");\n    const high = read(filter.second, \"second\");\n    return [...(low ? [call(\"ge\", c, low)] : []), ...(high ? [call(\"le\", c, high)] : [])];\n  }\n  const value = read(filter.first, \"first\");\n  return value ? [call(operator as FunctionName, c, value)] : [];\n}\n\nfunction isColumn(expr: Expr | undefined, name: string) {\n  return expr !== undefined && \"col\" in expr && expr.col === name;\n}\n\nfunction isLiteral(expr: Expr | undefined): expr is Literal {\n  return expr !== undefined && \"lit\" in expr;\n}\n\nfunction isCall(expr: Expr | undefined, fn: FunctionName): expr is { fn: FunctionName; args: Expr[] } {\n  return expr !== undefined && \"fn\" in expr && expr.fn === fn;\n}\n\n/** The text of a literal as the menu shows it to edit. */\nfunction literalText(literal: Literal): string {\n  return literal.lit === null ? \"\" : String(literal.lit);\n}\n\n/** `in(c, …)`, `is_blank(c)` or the `or` of both, as values. */\nfunction readValues(expr: Expr, name: string): { values: JsonValue[]; blank: boolean } | null {\n  const parts = isCall(expr, \"or\") ? expr.args : [expr];\n  let values: JsonValue[] | null = null;\n  let blank = false;\n  for (const part of parts) {\n    if (isCall(part, \"in\") && isColumn(part.args[0], name) && values === null && part.args.slice(1).every(isLiteral)) {\n      values = (part.args.slice(1) as Literal[]).map((literal) => literal.lit);\n    } else if (isCall(part, \"is_blank\") && isColumn(part.args[0], name) && !blank) {\n      blank = true;\n    } else {\n      return null;\n    }\n  }\n  return { values: values ?? [], blank };\n}\n\n/** `contains(lower(text(c)), lower(lit))` and the like: the operator and the text. */\nfunction readText(expr: Expr, name: string): { fn: FunctionName; text: string } | null {\n  if (!(\"fn\" in expr) || ![\"contains\", \"starts_with\", \"ends_with\"].includes(expr.fn)) return null;\n  const [haystack, needle] = expr.args;\n  if (!isCall(haystack, \"lower\") || !isCall(haystack.args[0], \"text\") || !isColumn(haystack.args[0].args[0], name)) {\n    return null;\n  }\n  if (!isCall(needle, \"lower\") || !isLiteral(needle.args[0]) || typeof needle.args[0].lit !== \"string\") return null;\n  return { fn: expr.fn, text: needle.args[0].lit };\n}\n\nconst COMPARISONS: FilterOperator[] = [\"eq\", \"ne\", \"lt\", \"le\", \"gt\", \"ge\"];\n\n/**\n * The filter that the conditions of a column (§6.2.1) make, when the menu wrote them or they have the same shape;\n * null when there are none, and `\"other\"` for conditions written otherwise (an agent, a saved view).\n */\nexport function readFilter(parts: readonly Expr[], name: string): ColumnFilter | \"other\" | null {\n  if (parts.length === 0) return null;\n  if (parts.length === 2) {\n    const [low, high] = parts;\n    if (\n      isCall(low, \"ge\") &&\n      isCall(high, \"le\") &&\n      isColumn(low.args[0], name) &&\n      isColumn(high.args[0], name) &&\n      isLiteral(low.args[1]) &&\n      isLiteral(high.args[1])\n    ) {\n      return {\n        kind: \"condition\",\n        operator: \"between\",\n        first: literalText(low.args[1]),\n        second: literalText(high.args[1]),\n      };\n    }\n    return \"other\";\n  }\n  if (parts.length !== 1) return \"other\";\n  const [part] = parts;\n  if (isLiteral(part) && part.lit === false) return { kind: \"values\", values: [], blank: false, exclude: false };\n  if (isCall(part, \"is_blank\") && isColumn(part.args[0], name)) {\n    return { kind: \"condition\", operator: \"blank\", first: \"\", second: \"\" };\n  }\n  if (isCall(part, \"not\")) {\n    const inner = part.args[0];\n    if (isCall(inner, \"is_blank\") && isColumn(inner.args[0], name)) {\n      return { kind: \"condition\", operator: \"notBlank\", first: \"\", second: \"\" };\n    }\n    if (isCall(inner, \"coalesce\") && isLiteral(inner.args[1]) && inner.args[1].lit === false) {\n      const matching = inner.args[0];\n      const values = readValues(matching, name);\n      if (values) return { kind: \"values\", ...values, exclude: true };\n      const text = readText(matching, name);\n      if (text?.fn === \"contains\") return { kind: \"condition\", operator: \"notContains\", first: text.text, second: \"\" };\n    }\n    return \"other\";\n  }\n  const values = readValues(part, name);\n  if (values && values.values.length > 0) return { kind: \"values\", ...values, exclude: false };\n  const text = readText(part, name);\n  if (text) {\n    const operator = text.fn === \"contains\" ? \"contains\" : text.fn === \"starts_with\" ? \"startsWith\" : \"endsWith\";\n    return { kind: \"condition\", operator, first: text.text, second: \"\" };\n  }\n  const comparison = COMPARISONS.find((fn) => isCall(part, fn as FunctionName));\n  if (comparison && isCall(part, comparison as FunctionName)) {\n    const [left, right] = part.args;\n    // One side of a range is read as the comparison it is.\n    if (isColumn(left, name) && isLiteral(right)) {\n      return { kind: \"condition\", operator: comparison, first: literalText(right), second: \"\" };\n    }\n  }\n  return \"other\";\n}\n\n/** The conditions of a column (§6.2.1): the parts of `where` that are not the search and refer to it and no other. */\nexport function conditionsOf(where: Expr | undefined, name: string): Expr[] {\n  return partsOf(where).filter((part) => {\n    if (\"search\" in part) return false;\n    const names = columnsOf(part);\n    return names.size === 1 && names.has(name);\n  });\n}\n\n/**\n * The plan whose rows are a column's values and how many rows have each, the most common first: the rows of\n * `plan` without its conditions on the column (so that the list holds the values that other filters leave), and\n * with those whose text contains `search`, ignoring letter case. Null when the plan groups rows.\n */\nexport function valuesPlan(plan: Plan, name: string, search: string): { plan: Plan; count: string } | null {\n  if (plan.aggregate) return null;\n  const own = new Set(conditionsOf(plan.where, name));\n  const parts = partsOf(plan.where).filter((part) => !own.has(part));\n  if (search.trim() !== \"\") {\n    parts.push(call(\"contains\", call(\"lower\", call(\"text\", { col: name })), call(\"lower\", { lit: search })));\n  }\n  let count = \"count\";\n  for (let n = 2; count === name; n++) count = `count ${n}`;\n  const where = joinParts(parts);\n  return {\n    plan: {\n      ...(plan.derive ? { derive: plan.derive } : {}),\n      ...(where ? { where } : {}),\n      aggregate: { keys: [name], measures: [{ name: count, fn: \"count\" }] },\n      sort: [\n        { column: count, direction: \"desc\" },\n        { column: name, direction: \"asc\" },\n      ],\n    },\n    count,\n  };\n}\n"],"mappings":"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","ignoreList":[]}

package/dist/core/format.d.ts

@@ -0,0 +1,14 @@
+/**
+ * How cells show their values with the `number` and `date` of a column's format (§5.1 of the specification): 0.1's
+ * `NumberFormat` and `DateFormat`, ported from `vastgrid-core` (Intl formats, with the exact digits of decimals,
+ * and date patterns such as `yyyy/MM/dd`).
+ */
+import type { Column, ColumnFormat, JsonValue } from "vastgrid-spec";
+/** Whether a column holds numbers. */
+export declare function isNumeric(column: Column): boolean;
+/**
+ * The text of values of a column by its format, or null where the format says nothing about a value (the grid then
+ * shows its text form, §2.4). Formats that Intl refuses (an unknown currency or time zone) give null for every value.
+ */
+export declare function formatterFor(column: Column, format: ColumnFormat | undefined, locale: string | undefined): ((value: JsonValue) => string | null) | null;
+//# sourceMappingURL=format.d.ts.map

package/dist/core/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../src/core/format.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,YAAY,EAAc,SAAS,EAAgB,MAAM,eAAe,CAAC;AAwQ/F,sCAAsC;AACtC,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,WAEvC;AAID;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,YAAY,GAAG,SAAS,EAChC,MAAM,EAAE,MAAM,GAAG,SAAS,GACzB,CAAC,CAAC,KAAK,EAAE,SAAS,KAAK,MAAM,GAAG,IAAI,CAAC,GAAG,IAAI,CAwB9C"}

package/dist/core/format.js

@@ -0,0 +1,303 @@
+/**
+ * How cells show their values with the `number` and `date` of a column's format (§5.1 of the specification): 0.1's
+ * `NumberFormat` and `DateFormat`, ported from `vastgrid-core` (Intl formats, with the exact digits of decimals,
+ * and date patterns such as `yyyy/MM/dd`).
+ */
+
+const decimalLiteral = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?$/;
+
+/**
+ * A value as input for `Intl.NumberFormat`, or null when it is not a finite number. Numeric strings
+ * stay strings, which `Intl.NumberFormat` formats from their exact digits.
+ */
+function numberInput(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : null;
+  if (typeof value !== "string") return null;
+  const text = value.trim();
+  return decimalLiteral.test(text) ? text : null;
+}
+function numberFormatter(locale, format, grouping) {
+  const style = format.style ?? "decimal";
+  if (style === "currency" && !format.currency) throw new RangeError("A currency format needs `currency`.");
+  const options = {
+    style,
+    useGrouping: format.grouping ?? grouping,
+    minimumFractionDigits: format.fractionDigits ?? format.minimumFractionDigits,
+    maximumFractionDigits: format.fractionDigits ?? format.maximumFractionDigits
+  };
+  if (style === "currency") {
+    options.currency = format.currency;
+    if (format.currencyDisplay) options.currencyDisplay = format.currencyDisplay;
+  }
+  if (format.notation) options.notation = format.notation;
+  if (format.signDisplay) options.signDisplay = format.signDisplay;
+  // A maximum below the style's default minimum (2 for USD, 0 for percent) lowers the minimum too.
+  if (options.maximumFractionDigits !== undefined && options.minimumFractionDigits === undefined) {
+    options.minimumFractionDigits = Math.min(options.maximumFractionDigits, new Intl.NumberFormat(locale, {
+      ...options,
+      maximumFractionDigits: undefined
+    }).resolvedOptions().minimumFractionDigits ?? 0);
+  }
+  const intl = new Intl.NumberFormat(locale, options);
+  const prefix = format.prefix ?? "";
+  const suffix = format.suffix ?? "";
+  // `format` takes exact decimal strings (Intl.NumberFormat v3); the types only list numbers.
+  return value => `${prefix}${intl.format(value)}${suffix}`;
+}
+
+/** The parts of an ISO-like date, time or timestamp. */
+
+const isoDateTime = /^([+-]?\d{4,})-(\d{2})-(\d{2})(?:[T ](\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?)?\s*(Z|[+-]\d{2}(?::?\d{2})?)?$/i;
+const isoTime = /^(\d{2}):(\d{2})(?::(\d{2})(?:\.(\d+))?)?$/;
+function parseOffset(text) {
+  if (!text) return null;
+  if (text.toUpperCase() === "Z") return 0;
+  const sign = text.startsWith("-") ? -1 : 1;
+  const digits = text.slice(1).replace(":", "");
+  return sign * (Number(digits.slice(0, 2)) * 60 + Number(digits.slice(2) || 0));
+}
+function parseDate(text) {
+  const date = isoDateTime.exec(text.trim());
+  if (date) {
+    const [, year, month, day, hour, minute, second, fraction, offset] = date;
+    return {
+      year: Number(year),
+      month: Number(month),
+      day: Number(day),
+      hour: Number(hour ?? 0),
+      minute: Number(minute ?? 0),
+      second: Number(second ?? 0),
+      fraction: fraction ?? "",
+      hasDate: true,
+      hasTime: hour !== undefined,
+      offset: parseOffset(offset)
+    };
+  }
+  const time = isoTime.exec(text.trim());
+  if (!time) return null;
+  const [, hour, minute, second, fraction] = time;
+  return {
+    year: 1970,
+    month: 1,
+    day: 1,
+    hour: Number(hour),
+    minute: Number(minute),
+    second: Number(second ?? 0),
+    fraction: fraction ?? "",
+    hasDate: false,
+    hasTime: true,
+    offset: null
+  };
+}
+
+/** The UTC time of the parts' wall clock (ignoring their offset). Years below 100 are kept. */
+function wallClock(parts) {
+  const date = new Date(0);
+  date.setUTCFullYear(parts.year, parts.month - 1, parts.day);
+  date.setUTCHours(parts.hour, parts.minute, parts.second, Number(parts.fraction.slice(0, 3).padEnd(3, "0")));
+  return date;
+}
+const patternToken = /'(?:[^']|'')*'|yyyy|yy|MMMM|MMM|MM|M|dd|d|EEEE|EEE|HH|H|hh|h|mm|m|ss|s|S+|a/g;
+function dateFormatter(locale, format) {
+  const {
+    pattern,
+    timeZone,
+    ...options
+  } = format;
+  // Checks the time zone and the options now, not on the first value.
+  new Intl.DateTimeFormat(locale, {
+    ...options,
+    timeZone
+  });
+  const custom = Object.keys(options).length > 0;
+  const formats = new Map();
+  const intl = (key, make) => {
+    let item = formats.get(key);
+    if (!item) {
+      item = make();
+      formats.set(key, item);
+    }
+    return item;
+  };
+  /** The parts in the shown time zone: values with an offset move to `timeZone`. */
+  const local = parts => {
+    if (parts.offset === null) return parts;
+    const instant = new Date(wallClock(parts).getTime() - parts.offset * 60_000);
+    const fields = intl("parts", () => new Intl.DateTimeFormat("en-US-u-nu-latn", {
+      timeZone,
+      year: "numeric",
+      month: "numeric",
+      day: "numeric",
+      hour: "numeric",
+      minute: "numeric",
+      second: "numeric",
+      hourCycle: "h23",
+      era: "short"
+    })).formatToParts(instant);
+    const field = type => Number(fields.find(part => part.type === type)?.value ?? 0);
+    const bc = fields.find(part => part.type === "era")?.value.startsWith("B");
+    return {
+      ...parts,
+      year: bc ? 1 - field("year") : field("year"),
+      month: field("month"),
+      day: field("day"),
+      hour: field("hour"),
+      minute: field("minute"),
+      second: field("second"),
+      offset: null
+    };
+  };
+  if (pattern !== undefined) {
+    const tokens = pattern.match(patternToken) ?? [];
+    const texts = pattern.split(patternToken);
+    const name = (key, options, date) => intl(key, () => new Intl.DateTimeFormat(locale, {
+      ...options,
+      timeZone: "UTC"
+    })).format(date);
+    const pad = (value, length) => value < 0 ? `-${String(-value).padStart(length, "0")}` : String(value).padStart(length, "0");
+    return parts => {
+      const shown = local(parts);
+      const date = wallClock(shown);
+      let text = texts[0];
+      tokens.forEach((token, index) => {
+        let part;
+        switch (token) {
+          case "yyyy":
+            part = pad(shown.year, 4);
+            break;
+          case "yy":
+            part = pad(Math.abs(shown.year) % 100, 2);
+            break;
+          case "MMMM":
+            part = name("MMMM", {
+              month: "long"
+            }, date);
+            break;
+          case "MMM":
+            part = name("MMM", {
+              month: "short"
+            }, date);
+            break;
+          case "MM":
+            part = pad(shown.month, 2);
+            break;
+          case "M":
+            part = String(shown.month);
+            break;
+          case "dd":
+            part = pad(shown.day, 2);
+            break;
+          case "d":
+            part = String(shown.day);
+            break;
+          case "EEEE":
+            part = name("EEEE", {
+              weekday: "long"
+            }, date);
+            break;
+          case "EEE":
+            part = name("EEE", {
+              weekday: "short"
+            }, date);
+            break;
+          case "HH":
+            part = pad(shown.hour, 2);
+            break;
+          case "H":
+            part = String(shown.hour);
+            break;
+          case "hh":
+            part = pad(shown.hour % 12 || 12, 2);
+            break;
+          case "h":
+            part = String(shown.hour % 12 || 12);
+            break;
+          case "a":
+            part = intl("a", () => new Intl.DateTimeFormat(locale, {
+              hour: "numeric",
+              hour12: true,
+              timeZone: "UTC"
+            })).formatToParts(date).find(item => item.type === "dayPeriod")?.value ?? (shown.hour < 12 ? "AM" : "PM");
+            break;
+          case "mm":
+            part = pad(shown.minute, 2);
+            break;
+          case "m":
+            part = String(shown.minute);
+            break;
+          case "ss":
+            part = pad(shown.second, 2);
+            break;
+          case "s":
+            part = String(shown.second);
+            break;
+          default:
+            part = token.startsWith("S") ? shown.fraction.slice(0, token.length).padEnd(token.length, "0") : token.slice(1, -1).replaceAll("''", "'");
+        }
+        text += part + texts[index + 1];
+      });
+      return text;
+    };
+  }
+  return parts => {
+    const zone = parts.offset !== null ? "z" : "";
+    const shape = custom ? `custom${zone}` : `${parts.hasDate ? "d" : ""}${parts.hasTime ? "t" : ""}${zone}`;
+    const item = intl(shape, () => {
+      const defaults = custom ? options : {};
+      if (!custom && parts.hasDate) Object.assign(defaults, {
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit"
+      });
+      if (!custom && parts.hasTime) Object.assign(defaults, {
+        hour: "2-digit",
+        minute: "2-digit",
+        second: "2-digit"
+      });
+      // Values without an offset are wall-clock times: show them as they are.
+      return new Intl.DateTimeFormat(locale, {
+        ...defaults,
+        timeZone: parts.offset !== null ? timeZone : "UTC"
+      });
+    });
+    const time = wallClock(parts).getTime() - (parts.offset ?? 0) * 60_000;
+    return item.format(time);
+  };
+}
+
+/** Whether a column holds numbers. */
+export function isNumeric(column) {
+  return column.type === "integer" || column.type === "bigint" || column.type === "decimal" || column.type === "float";
+}
+const TEMPORAL = new Set(["date", "time", "timestamp", "timestamptz"]);
+
+/**
+ * The text of values of a column by its format, or null where the format says nothing about a value (the grid then
+ * shows its text form, §2.4). Formats that Intl refuses (an unknown currency or time zone) give null for every value.
+ */
+export function formatterFor(column, format, locale) {
+  if (!format?.number && !format?.date) return null;
+  let number = null;
+  let date = null;
+  try {
+    if (format.number && isNumeric(column)) number = numberFormatter(locale, format.number, true);
+    if (format.date && TEMPORAL.has(column.type)) date = dateFormatter(locale, format.date);
+  } catch (error) {
+    if (error instanceof RangeError) return null;
+    throw error;
+  }
+  if (!number && !date) return null;
+  return value => {
+    if (value === null) return null;
+    if (number) {
+      const input = numberInput(value);
+      return input === null ? null : number(input);
+    }
+    if (date && typeof value === "string") {
+      const parts = parseDate(value.replace(/\+00$/, "Z"));
+      return parts ? date(parts) : null;
+    }
+    return null;
+  };
+}
+//# sourceMappingURL=format.js.map