ggaction 0.0.18 → 0.0.20

package/src/grammar/summary.js

@@ -1,320 +1 @@
-import { scalarKey } from "./transformKeys.js";
-import { rejectUnknownProperties as rejectUnknownKeys } from "../core/validation.js";
-import { requireStringValue as requireField } from "../core/validation.js";
-import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
-import {
-  aggregateRows,
-  isScalarAggregate,
-  validateAggregate,
-  validateAggregateFieldValues
-} from "./aggregate.js";
-import {
-  calculateWeightedAggregate,
-  normalizeStatisticalWeight,
-  readStatisticalWeights,
-  summarizeStatisticalWeights,
-  validateWeightedAggregate,
-  validateWeightedNumericFields,
-  weightedRows
-} from "./weightedStatistics.js";
-
-const TRANSFORM_KEYS = Object.freeze([
-  "type", "groupBy", "aggregates", "members", "weight", "missing", "empty"
-]);
-const AGGREGATE_KEYS = Object.freeze(["op", "field", "as"]);
-const NOMINAL_OPERATIONS = new Set(["distinct", "valid", "missing"]);
-const MAX_OUTPUT_ROWS = 10_000;
-
-function normalizeGroupBy(value) {
-  if (value === undefined) return [];
-  return Array.isArray(value) ? [...value] : [value];
-}
-
-function normalizeAggregate(value) {
-  if (!isPlainObject(value)) return value;
-  return {
-    ...value,
-    op: validateAggregate(value.op),
-    ...(Object.hasOwn(value, "field") ? { field: value.field } : {}),
-    as: value.as
-  };
-}
-
-export function normalizeSummaryTransform({ groupBy, aggregates, members, weight, missing, empty } = {}) {
-  const transform = {
-    type: "summary",
-    groupBy: normalizeGroupBy(groupBy),
-    aggregates: Array.isArray(aggregates)
-      ? aggregates.map(normalizeAggregate)
-      : aggregates,
-    ...(members === undefined ? {} : { members }),
-    ...(weight === undefined
-      ? {}
-      : { weight: normalizeStatisticalWeight(weight, "Summary weight") }),
-    ...(missing === undefined ? {} : { missing }),
-    ...(empty === undefined ? {} : { empty })
-  };
-  validateSummaryTransform(transform);
-  return cloneAndFreeze(transform);
-}
-
-export function validateSummaryTransform(transform) {
-  if (!isPlainObject(transform)) {
-    throw new TypeError("Summary transform must be a plain object.");
-  }
-  rejectUnknownKeys(transform, TRANSFORM_KEYS, "summary transform");
-  if (transform.type !== "summary") {
-    throw new Error(`Unsupported summary transform "${transform.type}".`);
-  }
-  if (
-    !Array.isArray(transform.groupBy) ||
-    transform.groupBy.some(field => typeof field !== "string" || field.length === 0)
-  ) {
-    throw new TypeError("Summary groupBy must contain field names.");
-  }
-  if (new Set(transform.groupBy).size !== transform.groupBy.length) {
-    throw new Error("Summary groupBy fields must be unique.");
-  }
-  if (!Array.isArray(transform.aggregates) || transform.aggregates.length === 0) {
-    throw new TypeError("Summary aggregates must be a non-empty array.");
-  }
-  if (transform.aggregates.length > 64) {
-    throw new RangeError("Summary aggregates cannot contain more than 64 outputs.");
-  }
-  const outputs = new Set(transform.groupBy);
-  transform.aggregates.forEach((aggregate, index) => {
-    if (!isPlainObject(aggregate)) {
-      throw new TypeError(`Summary aggregate ${index} must be a plain object.`);
-    }
-    rejectUnknownKeys(aggregate, AGGREGATE_KEYS, `summary aggregate ${index}`);
-    const operation = validateAggregate(aggregate.op);
-    if (transform.weight !== undefined) validateWeightedAggregate(operation);
-    if (operation === "count") {
-      if (Object.hasOwn(aggregate, "field")) {
-        throw new Error("Summary count does not accept a field.");
-      }
-    } else {
-      requireField(aggregate.field, `Summary aggregate ${index} field`);
-    }
-    const output = requireField(aggregate.as, `Summary aggregate ${index} as`);
-    if (outputs.has(output)) {
-      throw new Error(`Summary output field "${output}" collides with another output.`);
-    }
-    outputs.add(output);
-  });
-  if (transform.members !== undefined) {
-    const members = requireField(transform.members, "Summary members");
-    if (outputs.has(members)) {
-      throw new Error(`Summary members field "${members}" collides with another output.`);
-    }
-  }
-  if (transform.weight !== undefined) {
-    normalizeStatisticalWeight(transform.weight, "Summary weight");
-  }
-  if (transform.missing !== undefined && !["error", "drop"].includes(transform.missing)) {
-    throw new Error('Summary missing must be "error" or "drop".');
-  }
-  if (transform.empty !== undefined && !["null", "identity"].includes(transform.empty)) {
-    throw new Error('Summary empty must be "null" or "identity".');
-  }
-  return transform;
-}
-
-function requireSourceFields(rows, transform) {
-  if (rows.length === 0) return;
-  const fields = new Set(rows.flatMap(row => Object.keys(row)));
-  for (const field of transform.groupBy) {
-    if (!fields.has(field)) {
-      throw new Error(`Summary source does not contain group field "${field}".`);
-    }
-  }
-  for (const aggregate of transform.aggregates) {
-    if (aggregate.field !== undefined && !fields.has(aggregate.field)) {
-      throw new Error(`Summary source does not contain aggregate field "${aggregate.field}".`);
-    }
-    const orderBy = isPlainObject(aggregate.op) ? aggregate.op.orderBy : undefined;
-    if (orderBy !== undefined && !fields.has(orderBy)) {
-      throw new Error(`Summary source does not contain order field "${orderBy}".`);
-    }
-  }
-  if (transform.weight !== undefined && !fields.has(transform.weight.field)) {
-    throw new Error(`Summary source does not contain weight field "${transform.weight.field}".`);
-  }
-}
-
-function validateAggregateValues(rows, aggregate) {
-  if (aggregate.op === "count") return;
-  if (isScalarAggregate(aggregate.op) && NOMINAL_OPERATIONS.has(aggregate.op)) {
-    validateAggregateFieldValues(rows, aggregate.field, "nominal");
-    return;
-  }
-  validateAggregateFieldValues(rows, aggregate.field, "quantitative");
-}
-
-export function deriveSummaryRows(rows, transform) {
-  validateSummaryTransform(transform);
-  requireSourceFields(rows, transform);
-  const explicitWeighted = transform.weight !== undefined && transform.missing !== undefined;
-  let weightEntries;
-  if (transform.weight === undefined) {
-    for (const aggregate of transform.aggregates) {
-      validateAggregateValues(rows, aggregate);
-    }
-  } else if (!explicitWeighted) {
-    weightEntries = readStatisticalWeights(rows, transform.weight, "Summary").entries;
-    validateWeightedNumericFields(
-      weightEntries,
-      [...new Set(transform.aggregates.flatMap(aggregate =>
-        aggregate.field === undefined ? [] : [aggregate.field]
-      ))],
-      "Summary"
-    );
-  } else {
-    // Explicit missing policy is evaluated per measure. Validate every
-    // nonmissing value now, while leaving nullish value/weight pairs for the
-    // reason-priority accounting below.
-    readStatisticalWeights(
-      rows.filter(row => row[transform.weight.field] !== null && row[transform.weight.field] !== undefined),
-      transform.weight,
-      "Summary"
-    );
-    for (const aggregate of transform.aggregates) {
-      if (aggregate.field === undefined) continue;
-      validateAggregateValues(
-        rows.filter(row => row[aggregate.field] !== null && row[aggregate.field] !== undefined),
-        aggregate
-      );
-    }
-  }
-  if (transform.missing === "error") {
-    if (transform.weight !== undefined) {
-      const weightIndex = rows.findIndex(row =>
-        row[transform.weight.field] === null || row[transform.weight.field] === undefined
-      );
-      if (weightIndex !== -1) {
-        throw new TypeError(`Summary weight "${transform.weight.field}" is missing at row ${weightIndex}.`);
-      }
-    }
-    for (const aggregate of transform.aggregates) {
-      if (aggregate.field === undefined) continue;
-      const index = rows.findIndex(row => row[aggregate.field] === null || row[aggregate.field] === undefined);
-      if (index !== -1) throw new TypeError(`Summary field "${aggregate.field}" is missing at row ${index}.`);
-    }
-  }
-
-  const groups = new Map();
-  if (transform.groupBy.length === 0) {
-    groups.set("all", {
-      values: {},
-      rows,
-      ...(weightEntries === undefined ? {} : { entries: weightEntries })
-    });
-  } else {
-    rows.forEach((row, index) => {
-      const values = Object.fromEntries(transform.groupBy.map(field => [field, row[field]]));
-      const key = transform.groupBy.map(field =>
-        scalarKey(row[field], `Summary group field "${field}"`)
-      ).join("|");
-      const group = groups.get(key) ?? {
-        values,
-        rows: [],
-        ...(weightEntries === undefined ? {} : { entries: [] })
-      };
-      group.rows.push(row);
-      if (weightEntries !== undefined) group.entries.push(weightEntries[index]);
-      groups.set(key, group);
-    });
-  }
-  if (groups.size > MAX_OUTPUT_ROWS) {
-    throw new RangeError(`Summary output cannot exceed ${MAX_OUTPUT_ROWS} groups.`);
-  }
-
-  const units = [];
-  const values = [...groups.values()].map(group => {
-    const sharedWeightSummary = transform.weight === undefined || explicitWeighted
-      ? undefined
-      : summarizeStatisticalWeights(
-          group.entries,
-          transform.weight.kind,
-          "Summary group"
-        );
-    const aggregated = Object.fromEntries(transform.aggregates.map(aggregate => {
-      let missingValue = 0;
-      let missingWeight = 0;
-      let zeroWeightRows = 0;
-      let measureWeightSummary = sharedWeightSummary;
-      if (explicitWeighted) {
-        const eligible = group.rows.filter(row => {
-          if (aggregate.field !== undefined &&
-              (row[aggregate.field] === null || row[aggregate.field] === undefined)) {
-            missingValue += 1;
-            return false;
-          }
-          if (row[transform.weight.field] === null || row[transform.weight.field] === undefined) {
-            missingWeight += 1;
-            return false;
-          }
-          return true;
-        });
-        const entries = readStatisticalWeights(eligible, transform.weight, "Summary").entries;
-        zeroWeightRows = entries.filter(entry => entry.weight === 0).length;
-        measureWeightSummary = summarizeStatisticalWeights(
-          entries,
-          transform.weight.kind,
-          "Summary group"
-        );
-      }
-      let value = measureWeightSummary === undefined
-        ? aggregateRows(group.rows, aggregate.field ?? "__row", aggregate.op)
-        : calculateWeightedAggregate(
-            measureWeightSummary,
-            aggregate.field,
-            aggregate.op,
-            `Summary aggregate "${aggregate.as}"`
-          );
-      if (value === undefined && transform.empty !== undefined) {
-        const op = typeof aggregate.op === "string" ? aggregate.op : aggregate.op.op;
-        value = transform.empty === "identity" && op === "sum" ? 0 : null;
-      }
-      if (transform.missing !== undefined || transform.empty !== undefined) {
-        const missing = explicitWeighted
-          ? missingValue + missingWeight
-          : aggregate.field === undefined ? 0 : group.rows.filter(row => row[aggregate.field] === null || row[aggregate.field] === undefined).length;
-        units.push({
-          role: aggregate.as,
-          group: group.values,
-          inputRows: group.rows.length,
-          usedRows: group.rows.length - missing,
-          excludedRows: missing,
-          excludedByReason: missing === 0 ? {} : {
-            ...(missingValue === 0 && explicitWeighted ? {} : { "missing-value": explicitWeighted ? missingValue : missing }),
-            ...(missingWeight === 0 ? {} : { "missing-weight": missingWeight })
-          },
-          ...(explicitWeighted ? { zeroWeightRows } : {})
-        });
-      }
-      return [aggregate.as, value];
-    }));
-    return {
-      ...group.values,
-      ...aggregated,
-      ...(transform.members === undefined
-        ? {}
-        : {
-            [transform.members]: sharedWeightSummary === undefined
-              ? group.rows
-              : weightedRows(sharedWeightSummary)
-          })
-    };
-  });
-  if (transform.missing === undefined && transform.empty === undefined) return values;
-  return {
-    values,
-    report: cloneAndFreeze({
-      version: 1,
-      owner: { kind: "data", id: "pending" },
-      inputs: [],
-      units
-    })
-  };
-}
+import{createBootstrapMeanSampler as q,bootstrapMeanBounds as I,validateBootstrapDrawCount as U}from"./statistics/confidenceInterval.js";import{scalarKey as V}from"./transformKeys.js";import{rejectUnknownProperties as W}from"../core/validation.js";import{requireStringValue as E}from"../core/validation.js";import{cloneAndFreeze as v,isPlainObject as g}from"../core/immutable.js";import{aggregateRows as G,isScalarAggregate as K,validateAggregate as B,validateAggregateFieldValues as z}from"./aggregate.js";import{calculateWeightedAggregate as P,normalizeStatisticalWeight as M,readStatisticalWeights as A,summarizeStatisticalWeights as k,validateWeightedAggregate as J,validateWeightedNumericFields as L,weightedRows as Y}from"./weightedStatistics.js";const C=Object.freeze(["type","groupBy","aggregates","members","weight","missing","empty"]),D=Object.freeze(["op","field","as"]),X=new Set(["distinct","valid","missing"]),N=3e4;function H(e){return e===void 0?[]:Array.isArray(e)?[...e]:[e]}function Q(e){return g(e)?{...e,op:B(e.op,{allowBootstrap:!0}),...Object.hasOwn(e,"field")?{field:e.field}:{},as:e.as}:e}function ue({groupBy:e,aggregates:i,members:n,weight:o,missing:u,empty:l}={}){const m={type:"summary",groupBy:H(e),aggregates:Array.isArray(i)?i.map(Q):i,...n===void 0?{}:{members:n},...o===void 0?{}:{weight:M(o,"Summary weight")},...u===void 0?{}:{missing:u},...l===void 0?{}:{empty:l}};return x(m),v(m)}function x(e){if(!g(e))throw new TypeError("Summary transform must be a plain object.");if(W(e,C,"summary transform"),e.type!=="summary")throw new Error(`Unsupported summary transform "${e.type}".`);if(!Array.isArray(e.groupBy)||e.groupBy.some(n=>typeof n!="string"||n.length===0))throw new TypeError("Summary groupBy must contain field names.");if(new Set(e.groupBy).size!==e.groupBy.length)throw new Error("Summary groupBy fields must be unique.");if(!Array.isArray(e.aggregates)||e.aggregates.length===0)throw new TypeError("Summary aggregates must be a non-empty array.");if(e.aggregates.length>64)throw new RangeError("Summary aggregates cannot contain more than 64 outputs.");const i=new Set(e.groupBy);if(e.aggregates.forEach((n,o)=>{if(!g(n))throw new TypeError(`Summary aggregate ${o} must be a plain object.`);W(n,D,`summary aggregate ${o}`);const u=B(n.op,{allowBootstrap:!0});if(e.weight!==void 0&&J(u),u==="count"){if(Object.hasOwn(n,"field"))throw new Error("Summary count does not accept a field.")}else E(n.field,`Summary aggregate ${o} field`);const l=E(n.as,`Summary aggregate ${o} as`);if(i.has(l))throw new Error(`Summary output field "${l}" collides with another output.`);i.add(l)}),e.members!==void 0){const n=E(e.members,"Summary members");if(i.has(n))throw new Error(`Summary members field "${n}" collides with another output.`)}if(e.weight!==void 0&&M(e.weight,"Summary weight"),e.missing!==void 0&&!["error","drop"].includes(e.missing))throw new Error('Summary missing must be "error" or "drop".');if(e.empty!==void 0&&!["null","identity"].includes(e.empty))throw new Error('Summary empty must be "null" or "identity".');return e}function Z(e,i){if(e.length===0)return;const n=new Set(e.flatMap(o=>Object.keys(o)));for(const o of i.groupBy)if(!n.has(o))throw new Error(`Summary source does not contain group field "${o}".`);for(const o of i.aggregates){if(o.field!==void 0&&!n.has(o.field))throw new Error(`Summary source does not contain aggregate field "${o.field}".`);const u=g(o.op)?o.op.orderBy:void 0;if(u!==void 0&&!n.has(u))throw new Error(`Summary source does not contain order field "${u}".`)}if(i.weight!==void 0&&!n.has(i.weight.field))throw new Error(`Summary source does not contain weight field "${i.weight.field}".`)}function F(e,i){if(i.op!=="count"){if(K(i.op)&&X.has(i.op)){z(e,i.field,"nominal");return}z(e,i.field,"quantitative")}}function se(e,i){x(i),Z(e,i);const n=i.aggregates.map(t=>({...t,op:B(t.op,{allowBootstrap:!0})})),o=i.weight!==void 0&&i.missing!==void 0;let u;if(i.weight===void 0)for(const t of n)F(e,t);else if(!o)u=A(e,i.weight,"Summary").entries,L(u,[...new Set(n.flatMap(t=>t.field===void 0?[]:[t.field]))],"Summary");else{A(e.filter(t=>t[i.weight.field]!==null&&t[i.weight.field]!==void 0),i.weight,"Summary");for(const t of n)t.field!==void 0&&F(e.filter(d=>d[t.field]!==null&&d[t.field]!==void 0),t)}if(i.missing==="error"){if(i.weight!==void 0){const t=e.findIndex(d=>d[i.weight.field]===null||d[i.weight.field]===void 0);if(t!==-1)throw new TypeError(`Summary weight "${i.weight.field}" is missing at row ${t}.`)}for(const t of n){if(t.field===void 0)continue;const d=e.findIndex(f=>f[t.field]===null||f[t.field]===void 0);if(d!==-1)throw new TypeError(`Summary field "${t.field}" is missing at row ${d}.`)}}const l=new Map;if(i.groupBy.length===0?l.set("all",{values:{},rows:e,...u===void 0?{}:{entries:u}}):e.forEach((t,d)=>{const f=Object.fromEntries(i.groupBy.map(a=>[a,t[a]])),c=i.groupBy.map(a=>V(t[a],`Summary group field "${a}"`)).join("|"),r=l.get(c)??{values:f,rows:[],...u===void 0?{}:{entries:[]}};r.rows.push(t),u!==void 0&&r.entries.push(u[d]),l.set(c,r)}),l.size>N)throw new RangeError(`Summary output cannot exceed ${N} groups.`);const m=new Map;let O=0;for(const t of n){const d=t.op?.method;if(d?.type!=="bootstrap")continue;const f=JSON.stringify([t.field,d.samples,d.seed]);m.has(f)||(O+=d.samples*e.filter(c=>Number.isFinite(c[t.field])).length,U(O),m.set(f,q(d)))}const $=[],R=[...l.values()].map(t=>{const d=new Map,f=i.weight===void 0||o?void 0:k(t.entries,i.weight.kind,"Summary group"),c=Object.fromEntries(n.map(r=>{let a=0,h=0,j=0,S=f;if(o){const s=t.rows.filter(p=>r.field!==void 0&&(p[r.field]===null||p[r.field]===void 0)?(a+=1,!1):p[i.weight.field]===null||p[i.weight.field]===void 0?(h+=1,!1):!0),y=A(s,i.weight,"Summary").entries;j=y.filter(p=>p.weight===0).length,S=k(y,i.weight.kind,"Summary group")}const w=r.op?.method;let T;if(w?.type==="bootstrap"){const s=JSON.stringify([r.field,w.samples,w.seed]);if(!d.has(s)){const p=t.rows.map(_=>_[r.field]).filter(Number.isFinite);d.set(s,m.get(s)(p))}T=I(d.get(s),r.op.level)?.[r.op.op==="ciLower"?"lower":"upper"]}let b=w?.type==="bootstrap"?T:S===void 0?G(t.rows,r.field??"__row",r.op):P(S,r.field,r.op,`Summary aggregate "${r.as}"`);if(b===void 0&&i.empty!==void 0){const s=typeof r.op=="string"?r.op:r.op.op;b=i.empty==="identity"&&s==="sum"?0:null}if(i.missing!==void 0||i.empty!==void 0){const s=o?a+h:r.field===void 0?0:t.rows.filter(y=>y[r.field]===null||y[r.field]===void 0).length;$.push({role:r.as,group:t.values,inputRows:t.rows.length,usedRows:t.rows.length-s,excludedRows:s,excludedByReason:s===0?{}:{...a===0&&o?{}:{"missing-value":o?a:s},...h===0?{}:{"missing-weight":h}},...o?{zeroWeightRows:j}:{}})}return[r.as,b]}));return{...t.values,...c,...i.members===void 0?{}:{[i.members]:f===void 0?t.rows:Y(f)}}});return i.missing===void 0&&i.empty===void 0?R:{values:R,report:v({version:1,owner:{kind:"data",id:"pending"},inputs:[],units:$})}}export{se as deriveSummaryRows,ue as normalizeSummaryTransform,x as validateSummaryTransform};

package/src/grammar/timeUnit.js

@@ -52,6 +52,7 @@ function formatter(timeZone) {
     try {
       value = new Intl.DateTimeFormat("en-US-u-ca-gregory-nu-latn", {
         timeZone,
+        era: "short",
         year: "numeric",
         month: "2-digit",
         day: "2-digit",
@@ -68,7 +69,7 @@ function formatter(timeZone) {
   return CALENDAR_FORMATTERS.get(timeZone);
 }
 
-function validateTimeZone(timeZone) {
+export function validateTimeZone(timeZone) {
   if (typeof timeZone !== "string" || timeZone.length === 0) {
     throw new TypeError("Time-unit timeZone must be a non-empty IANA time-zone name.");
   }
@@ -178,17 +179,18 @@ export function calendarParts(timestamp, timeZone) {
   validateTimeZone(timeZone);
   const parts = Object.fromEntries(formatter(timeZone).formatToParts(timestamp)
     .filter(part => part.type !== "literal")
-    .map(part => [part.type, Number(part.value)]));
+    .map(part => [part.type, part.type === "era" ? part.value : Number(part.value)]));
+  const year = parts.era === "BC" ? 1 - parts.year : parts.year;
   const millisecond = ((timestamp % 1000) + 1000) % 1000;
   return {
-    year: parts.year,
+    year,
     month: parts.month,
     day: parts.day,
     hour: parts.hour,
     minute: parts.minute,
     second: parts.second,
     millisecond,
-    weekday: weekdayFromDate(parts.year, parts.month, parts.day)
+    weekday: weekdayFromDate(year, parts.month, parts.day)
   };
 }
 

package/src/grammar/transformTopology.js

@@ -16,6 +16,7 @@ const TRANSFORM_TOPOLOGY = Object.freeze({
   markFilter: Object.freeze({ provenanceTransparent: true }),
   normalize: Object.freeze({ facetTopology: "statistical" }),
   regression: Object.freeze({ facetTopology: "statistical" }),
+  regressionStatistics: Object.freeze({ facetTopology: "statistical" }),
   sort: Object.freeze({ facetTopology: "statistical" }),
   summary: Object.freeze({ facetTopology: "statistical" }),
   stack: Object.freeze({ facetTopology: "statistical" }),

package/src/grammar/transforms.js

@@ -1,4 +1,5 @@
 import { cloneAndFreeze, isPlainObject } from "../core/immutable.js";
+import { validateRegressionStatisticsTransform } from "./regression/statistics.js";
 import { validateBoxTransform } from "./boxPlot.js";
 import { normalizeBinTransform, validateBinTransform } from "./bin.js";
 import {
@@ -203,7 +204,7 @@ function normalizeRegressionEdit(transform, patch) {
       delete base.span;
       delete base.robustIterations;
     }
-    if (method === "loess" || base.method === "loess") {
+    if (["loess", "exp"].includes(method) || ["loess", "exp"].includes(base.method)) {
       for (const key of [
         "confidenceMethod", "level", "confidence", "interval"
       ]) delete base[key];
@@ -446,6 +447,15 @@ const TRANSFORM_POLICIES = Object.freeze({
     normalizeEdit: normalizeRegressionEdit,
     outputRoles: () => ({})
   }),
+  regressionStatistics: Object.freeze({
+    ...findTransformTopology("regressionStatistics"),
+    validate: validateRegressionStatisticsTransform,
+    materializeOp: "materializeRegressionStatisticsData",
+    replayTransform: requestedTransform,
+    editable: true,
+    normalizeEdit: (transform, patch) => validateRegressionStatisticsTransform({ ...transform, ...patch }),
+    outputRoles: () => ({ count: "count", intercept: "intercept", slope: "slope", rSquared: "rSquared" })
+  }),
   sort: Object.freeze({
     ...findTransformTopology("sort"),
     validate: validateSortTransform,