{"version":3,"file":"tableParams.cjs","names":["isNil","distillFilterSpec","isLabelColumn","getAxisId","matchAxisId","isLinkerColumn","canonicalizeJson","ValueType"],"sources":["../../../src/components/PlDataTable/tableParams.ts"],"sourcesContent":["import type {\n  AxisId,\n  AxisSpec,\n  CanonicalizedJson,\n  ColumnUniversalId,\n  FilterSpecNode,\n  PColumnSpec,\n  PTableColumnId,\n  PTableSorting,\n} from \"@milaboratories/pl-model-common\";\nimport {\n  canonicalizeJson,\n  getAxisId,\n  isLabelColumn,\n  isLinkerColumn,\n  matchAxisId,\n  ValueType,\n} from \"@milaboratories/pl-model-common\";\nimport { isNil } from \"es-toolkit\";\nimport { distillFilterSpec } from \"../../filters\";\nimport type {\n  PlDataTableFilters,\n  PlDataTableFiltersWithMeta,\n  PlDataTableFilterSpecLeaf,\n  PlDataTableSheetState,\n  PlDataTableStateV2CacheEntry,\n  PlDataTableStateV2Normalized,\n} from \"./typesV8\";\n\n/** What the user set up for the table of the source the UI shows. */\nexport type PlDataTableUserParams = {\n  /** Source the UI shows; `null` until the UI has shown one. */\n  sourceId: null | string;\n  /** The value picked on each sheet. */\n  sheetsState: PlDataTableSheetState[];\n  /** The user's own filters without the suppressed ones; `null` when there are none. */\n  userFilters: null | PlDataTableFilters;\n  /**\n   * The user's edit of the default filters: `null` while untouched, so the block's\n   * defaults apply, and an empty group once every default is suppressed.\n   */\n  defaultFilters: null | PlDataTableFilters;\n  /** Fast-search text, trimmed; `null` when empty. */\n  searchString: null | string;\n  /** `null` while untouched, so the block's default sorting applies; `[]` once cleared. */\n  sorting: null | PTableSorting[];\n  /** Columns the user hid; `null` while untouched, so optional columns stay hidden. */\n  hiddenColIds: null | PTableColumnId[];\n};\n\n/** A column the fast search looks into. */\nexport type PlDataTableSearchColumn = {\n  id: PTableColumnId;\n  valueType: ValueType;\n};\n\n/** A column of the table as the fast search sees it. */\nexport type PlDataTableSearchCandidate = {\n  id: ColumnUniversalId;\n  spec: PColumnSpec;\n  visibility: \"default\" | \"optional\" | \"hidden\";\n};\n\n/** Read the user's settings for the source the stored state points at. */\nexport function readPlDataTableUserParams(\n  state: PlDataTableStateV2Normalized,\n): PlDataTableUserParams {\n  const sourceId = state.pTableParams.sourceId;\n  const entry = findEntry(state, sourceId);\n  if (isNil(entry)) {\n    return {\n      sourceId,\n      sheetsState: [],\n      userFilters: null,\n      defaultFilters: null,\n      searchString: null,\n      sorting: null,\n      hiddenColIds: null,\n    };\n  }\n\n  return {\n    sourceId,\n    sheetsState: entry.sheetsState,\n    userFilters: isNil(entry.filtersState)\n      ? null\n      : distillFilterSpec(stripSuppressedFilters(entry.filtersState)),\n    defaultFilters: isNil(entry.defaultFiltersState)\n      ? null\n      : (distillFilterSpec(stripSuppressedFilters(entry.defaultFiltersState)) ?? emptyGroup()),\n    searchString: entry.searchString?.trim() || null,\n    sorting: entry.sorting,\n    hiddenColIds: entry.hiddenColIds,\n  };\n}\n\n/** One filter per sheet, selecting the value picked on it. */\nexport function createSheetFilters(sheetsState: PlDataTableSheetState[]): PlDataTableFilterNode[] {\n  return sheetsState.map((sheet) => {\n    const column: PTableColumnId = { type: \"axis\", id: sheet.axisId };\n    return typeof sheet.value === \"number\"\n      ? { type: \"equal\", column, x: sheet.value }\n      : { type: \"patternEquals\", column, value: sheet.value };\n  });\n}\n\n/**\n * The columns the fast search looks into: the visible ones, and the visible axes\n * except those a sheet fixes to a single value, where every row would match, and\n * those the table shows through their label column, whose raw values are never\n * on screen. Hidden are columns the block's rules hide, linker columns, and the\n * columns in the user's hidden list, or, while the user has not touched it, the\n * optional ones.\n */\nexport function collectSearchColumns(params: {\n  columns: PlDataTableSearchCandidate[];\n  isAxisHidden: (axis: AxisSpec) => boolean;\n  sheetAxes: AxisId[];\n  hiddenColIds: null | PTableColumnId[];\n}): PlDataTableSearchColumn[] {\n  const { columns, isAxisHidden, sheetAxes, hiddenColIds } = params;\n  const sheetAxisKeys = new Set(sheetAxes.map(axisKey));\n  const labeledAxes = columns\n    .filter((c) => isLabelColumn(c.spec))\n    .flatMap((c) => c.spec.axesSpec.map(getAxisId));\n  const shownAxes = uniqueAxes(columns.flatMap((c) => c.spec.axesSpec)).filter((axis) => {\n    const id = getAxisId(axis);\n    return (\n      !sheetAxisKeys.has(axisKey(id)) &&\n      !isAxisHidden(axis) &&\n      !labeledAxes.some((labeled) => matchAxisId(labeled, id))\n    );\n  });\n  const shownColumns = columns.filter((c) => c.visibility !== \"hidden\" && !isLinkerColumn(c.spec));\n\n  const hidden = new Set(\n    (\n      hiddenColIds ??\n      shownColumns\n        .filter((c) => c.visibility === \"optional\")\n        .map((c): PTableColumnId => ({ type: \"column\", id: c.id }))\n    ).map((id) => canonicalizeJson<PTableColumnId>(id)),\n  );\n\n  return [\n    ...shownAxes.map((axis): PlDataTableSearchColumn => ({\n      id: { type: \"axis\", id: getAxisId(axis) },\n      valueType: axis.type,\n    })),\n    ...shownColumns.map((c): PlDataTableSearchColumn => ({\n      id: { type: \"column\", id: c.id },\n      valueType: c.spec.valueType,\n    })),\n  ].filter((c) => !hidden.has(canonicalizeJson<PTableColumnId>(c.id)));\n}\n\n/**\n * The fast search as a filter: a row matches when any searched column holds the\n * text exactly, or, for a number, holds that number.\n */\nexport function createSearchFilter(\n  searchString: null | string,\n  columns: PlDataTableSearchColumn[],\n): null | PlDataTableFilters {\n  if (isNil(searchString)) return null;\n  const number = Number(searchString);\n  const isNumber = searchString.length > 0 && Number.isFinite(number);\n\n  const parts = columns.flatMap((c): PlDataTableFilterNode[] => {\n    if (c.valueType === ValueType.String) {\n      return [{ type: \"patternEquals\", column: c.id, value: searchString }];\n    }\n    if (isNumericValueType(c.valueType) && isNumber) {\n      return [{ type: \"equal\", column: c.id, x: number }];\n    }\n    return [];\n  });\n\n  return parts.length === 0 ? null : { type: \"or\", filters: parts };\n}\n\n/** AND of the given filter trees, `null` when none is left. */\nexport function joinFilters(\n  filters: (null | undefined | PlDataTableFilterNode)[],\n): null | PlDataTableFilters {\n  const operands = filters.flatMap((f): PlDataTableFilterNode[] => {\n    if (isNil(f)) return [];\n    return f.type === \"and\" ? f.filters : [f];\n  });\n  return operands.length === 0 ? null : { type: \"and\", filters: operands };\n}\n\nexport type PlDataTableFilterNode = FilterSpecNode<PlDataTableFilterSpecLeaf>;\n\n// Internals\n\nfunction findEntry(\n  state: PlDataTableStateV2Normalized,\n  sourceId: null | string,\n): undefined | PlDataTableStateV2CacheEntry {\n  if (isNil(sourceId)) return undefined;\n  return state.stateCache.find((entry) => entry.sourceId === sourceId);\n}\n\nfunction stripSuppressedFilters(node: PlDataTableFiltersWithMeta): PlDataTableFiltersWithMeta {\n  return {\n    ...node,\n    filters: node.filters\n      .filter((child) => !(\"isSuppressed\" in child && child.isSuppressed === true))\n      .map((child) =>\n        (child.type === \"and\" || child.type === \"or\") && \"filters\" in child\n          ? stripSuppressedFilters(child)\n          : child,\n      ),\n  };\n}\n\nfunction emptyGroup(): PlDataTableFilters {\n  return { type: \"and\", filters: [] };\n}\n\nfunction isNumericValueType(valueType: ValueType): boolean {\n  return (\n    valueType === ValueType.Int ||\n    valueType === ValueType.Long ||\n    valueType === ValueType.Float ||\n    valueType === ValueType.Double\n  );\n}\n\nfunction axisKey(axisId: AxisId): CanonicalizedJson<AxisId> {\n  return canonicalizeJson<AxisId>(axisId);\n}\n\nfunction uniqueAxes(axes: AxisSpec[]): AxisSpec[] {\n  const seen = new Set<CanonicalizedJson<AxisId>>();\n  return axes.filter((axis) => {\n    const key = axisKey(getAxisId(axis));\n    if (seen.has(key)) return false;\n    seen.add(key);\n    return true;\n  });\n}\n"],"mappings":";;;;;;AAgEA,SAAgB,0BACd,OACuB;CACvB,MAAM,WAAW,MAAM,aAAa;CACpC,MAAM,QAAQ,UAAU,OAAO,QAAQ;CACvC,KAAA,GAAIA,WAAAA,MAAAA,CAAM,KAAK,GACb,OAAO;EACL;EACA,aAAa,CAAC;EACd,aAAa;EACb,gBAAgB;EAChB,cAAc;EACd,SAAS;EACT,cAAc;CAChB;CAGF,OAAO;EACL;EACA,aAAa,MAAM;EACnB,cAAA,GAAaA,WAAAA,MAAAA,CAAM,MAAM,YAAY,IACjC,OACAC,gBAAAA,kBAAkB,uBAAuB,MAAM,YAAY,CAAC;EAChE,iBAAA,GAAgBD,WAAAA,MAAAA,CAAM,MAAM,mBAAmB,IAC3C,OACCC,gBAAAA,kBAAkB,uBAAuB,MAAM,mBAAmB,CAAC,KAAK,WAAW;EACxF,cAAc,MAAM,cAAc,KAAK,KAAK;EAC5C,SAAS,MAAM;EACf,cAAc,MAAM;CACtB;AACF;;AAGA,SAAgB,mBAAmB,aAA+D;CAChG,OAAO,YAAY,KAAK,UAAU;EAChC,MAAM,SAAyB;GAAE,MAAM;GAAQ,IAAI,MAAM;EAAO;EAChE,OAAO,OAAO,MAAM,UAAU,WAC1B;GAAE,MAAM;GAAS;GAAQ,GAAG,MAAM;EAAM,IACxC;GAAE,MAAM;GAAiB;GAAQ,OAAO,MAAM;EAAM;CAC1D,CAAC;AACH;;;;;;;;;AAUA,SAAgB,qBAAqB,QAKP;CAC5B,MAAM,EAAE,SAAS,cAAc,WAAW,iBAAiB;CAC3D,MAAM,gBAAgB,IAAI,IAAI,UAAU,IAAI,OAAO,CAAC;CACpD,MAAM,cAAc,QACjB,QAAQ,OAAA,GAAMC,gCAAAA,cAAAA,CAAc,EAAE,IAAI,CAAC,CAAC,CACpC,SAAS,MAAM,EAAE,KAAK,SAAS,IAAIC,gCAAAA,SAAS,CAAC;CAChD,MAAM,YAAY,WAAW,QAAQ,SAAS,MAAM,EAAE,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,SAAS;EACrF,MAAM,MAAA,GAAKA,gCAAAA,UAAAA,CAAU,IAAI;EACzB,OACE,CAAC,cAAc,IAAI,QAAQ,EAAE,CAAC,KAC9B,CAAC,aAAa,IAAI,KAClB,CAAC,YAAY,MAAM,aAAA,GAAYC,gCAAAA,YAAAA,CAAY,SAAS,EAAE,CAAC;CAE3D,CAAC;CACD,MAAM,eAAe,QAAQ,QAAQ,MAAM,EAAE,eAAe,YAAY,EAAA,GAACC,gCAAAA,eAAAA,CAAe,EAAE,IAAI,CAAC;CAE/F,MAAM,SAAS,IAAI,KAEf,gBACA,aACG,QAAQ,MAAM,EAAE,eAAe,UAAU,CAAC,CAC1C,KAAK,OAAuB;EAAE,MAAM;EAAU,IAAI,EAAE;CAAG,EAAE,EAAA,CAC5D,KAAK,QAAA,GAAOC,gCAAAA,iBAAAA,CAAiC,EAAE,CAAC,CACpD;CAEA,OAAO,CACL,GAAG,UAAU,KAAK,UAAmC;EACnD,IAAI;GAAE,MAAM;GAAQ,KAAA,GAAIH,gCAAAA,UAAAA,CAAU,IAAI;EAAE;EACxC,WAAW,KAAK;CAClB,EAAE,GACF,GAAG,aAAa,KAAK,OAAgC;EACnD,IAAI;GAAE,MAAM;GAAU,IAAI,EAAE;EAAG;EAC/B,WAAW,EAAE,KAAK;CACpB,EAAE,CACJ,CAAC,CAAC,QAAQ,MAAM,CAAC,OAAO,KAAA,GAAIG,gCAAAA,iBAAAA,CAAiC,EAAE,EAAE,CAAC,CAAC;AACrE;;;;;AAMA,SAAgB,mBACd,cACA,SAC2B;CAC3B,KAAA,GAAIN,WAAAA,MAAAA,CAAM,YAAY,GAAG,OAAO;CAChC,MAAM,SAAS,OAAO,YAAY;CAClC,MAAM,WAAW,aAAa,SAAS,KAAK,OAAO,SAAS,MAAM;CAElE,MAAM,QAAQ,QAAQ,SAAS,MAA+B;EAC5D,IAAI,EAAE,cAAcO,gCAAAA,UAAU,QAC5B,OAAO,CAAC;GAAE,MAAM;GAAiB,QAAQ,EAAE;GAAI,OAAO;EAAa,CAAC;EAEtE,IAAI,mBAAmB,EAAE,SAAS,KAAK,UACrC,OAAO,CAAC;GAAE,MAAM;GAAS,QAAQ,EAAE;GAAI,GAAG;EAAO,CAAC;EAEpD,OAAO,CAAC;CACV,CAAC;CAED,OAAO,MAAM,WAAW,IAAI,OAAO;EAAE,MAAM;EAAM,SAAS;CAAM;AAClE;;AAGA,SAAgB,YACd,SAC2B;CAC3B,MAAM,WAAW,QAAQ,SAAS,MAA+B;EAC/D,KAAA,GAAIP,WAAAA,MAAAA,CAAM,CAAC,GAAG,OAAO,CAAC;EACtB,OAAO,EAAE,SAAS,QAAQ,EAAE,UAAU,CAAC,CAAC;CAC1C,CAAC;CACD,OAAO,SAAS,WAAW,IAAI,OAAO;EAAE,MAAM;EAAO,SAAS;CAAS;AACzE;AAMA,SAAS,UACP,OACA,UAC0C;CAC1C,KAAA,GAAIA,WAAAA,MAAAA,CAAM,QAAQ,GAAG,OAAO,KAAA;CAC5B,OAAO,MAAM,WAAW,MAAM,UAAU,MAAM,aAAa,QAAQ;AACrE;AAEA,SAAS,uBAAuB,MAA8D;CAC5F,OAAO;EACL,GAAG;EACH,SAAS,KAAK,QACX,QAAQ,UAAU,EAAE,kBAAkB,SAAS,MAAM,iBAAiB,KAAK,CAAC,CAC5E,KAAK,WACH,MAAM,SAAS,SAAS,MAAM,SAAS,SAAS,aAAa,QAC1D,uBAAuB,KAAK,IAC5B,KACN;CACJ;AACF;AAEA,SAAS,aAAiC;CACxC,OAAO;EAAE,MAAM;EAAO,SAAS,CAAC;CAAE;AACpC;AAEA,SAAS,mBAAmB,WAA+B;CACzD,OACE,cAAcO,gCAAAA,UAAU,OACxB,cAAcA,gCAAAA,UAAU,QACxB,cAAcA,gCAAAA,UAAU,SACxB,cAAcA,gCAAAA,UAAU;AAE5B;AAEA,SAAS,QAAQ,QAA2C;CAC1D,QAAA,GAAOD,gCAAAA,iBAAAA,CAAyB,MAAM;AACxC;AAEA,SAAS,WAAW,MAA8B;CAChD,MAAM,uBAAO,IAAI,IAA+B;CAChD,OAAO,KAAK,QAAQ,SAAS;EAC3B,MAAM,MAAM,SAAA,GAAQH,gCAAAA,UAAAA,CAAU,IAAI,CAAC;EACnC,IAAI,KAAK,IAAI,GAAG,GAAG,OAAO;EAC1B,KAAK,IAAI,GAAG;EACZ,OAAO;CACT,CAAC;AACH"}