{"version":3,"file":"state-migration.cjs","names":["parseJsonSafely","isNil","canonicalizeJson","getPTableColumnId","distillFilterSpec","isColumnUniversalKey","stringifyColumnDiscoveredId"],"sources":["../../../src/components/PlDataTable/state-migration.ts"],"sourcesContent":["import type {\n  AxisId,\n  AxisQualification,\n  CanonicalizedJson,\n  ColumnUniversalId,\n  PObjectId,\n  PTableColumnId,\n  PTableColumnSpec,\n  PTableRecordFilter,\n  PTableSorting,\n} from \"@milaboratories/pl-model-common\";\nimport {\n  canonicalizeJson,\n  getPTableColumnId,\n  isColumnUniversalKey,\n  parseJsonSafely,\n  stringifyColumnDiscoveredId,\n} from \"@milaboratories/pl-model-common\";\nimport { distillFilterSpec } from \"../../filters\";\nimport type { PlDataTableFilterState, PlTableFilter } from \"./typesV4\";\nimport type {\n  PlDataTableFilters,\n  PlDataTableFiltersWithMeta,\n  PlDataTableGridStateCore,\n  PlDataTableSheetState,\n  PlDataTableStateV2CacheEntry,\n  PlDataTableStateV2Normalized,\n  PlTableColumnIdJson as PlTableColumnIdJsonV8,\n  PTableParamsV2,\n} from \"./typesV8\";\nimport type {\n  PlDataTableFilters as PlDataTableFiltersV7,\n  PlDataTableFiltersWithMeta as PlDataTableFiltersWithMetaV7,\n  PlDataTableGridStateCore as PlDataTableGridStateCoreV7,\n  PlDataTableStateV2CacheEntry as PlDataTableStateV2V7CacheEntry,\n  PlDataTableStateV2Normalized as PlDataTableStateV2V7,\n  PlTableColumnIdJson,\n  PTableParamsV2 as PTableParamsV2V7,\n} from \"./typesV7\";\nimport type {\n  PlDataTableGridStateV6,\n  PlDataTableStateV2V6,\n  PlDataTableStateV2V6CacheEntry,\n  PlDataTableV6ColIdJson,\n} from \"./typesV6\";\nimport type {\n  PlDataTableGridStateV5,\n  PlDataTableV5ColIdJson,\n  PlDataTableV5ColIdWrapper,\n} from \"./typesV5\";\nimport { isNil } from \"es-toolkit\";\n\n/**\n * PlDataTableV2 persisted state\n */\nexport type PlDataTableStateV2 =\n  // Old versions of the state\n  | {\n      // no version\n      gridState: {\n        columnOrder?: {\n          orderedColIds: CanonicalizedJson<PTableColumnSpec>[];\n        };\n        sort?: {\n          sortModel: {\n            colId: CanonicalizedJson<PTableColumnSpec>;\n            sort: \"asc\" | \"desc\";\n          }[];\n        };\n        columnVisibility?: {\n          hiddenColIds: CanonicalizedJson<PTableColumnSpec>[];\n        };\n        sourceId?: string;\n        sheets?: Record<CanonicalizedJson<AxisId>, string | number>;\n      };\n      pTableParams?: {\n        sorting?: PTableSorting[];\n        filters?: PTableRecordFilter[];\n      };\n    }\n  | {\n      version: 2;\n      stateCache: {\n        sourceId: string;\n        gridState: {\n          columnOrder?: {\n            orderedColIds: CanonicalizedJson<PTableColumnSpec>[];\n          };\n          sort?: {\n            sortModel: {\n              colId: CanonicalizedJson<PTableColumnSpec>;\n              sort: \"asc\" | \"desc\";\n            }[];\n          };\n          columnVisibility?: {\n            hiddenColIds: CanonicalizedJson<PTableColumnSpec>[];\n          };\n        };\n        sheetsState: PlDataTableSheetState[];\n      }[];\n      pTableParams: {\n        hiddenColIds: PObjectId[] | null;\n        filters: PTableRecordFilter[];\n        sorting: PTableSorting[];\n      };\n    }\n  | {\n      version: 3;\n      stateCache: {\n        sourceId: string;\n        gridState: {\n          columnOrder?: {\n            orderedColIds: CanonicalizedJson<PTableColumnSpec>[];\n          };\n          sort?: {\n            sortModel: {\n              colId: CanonicalizedJson<PTableColumnSpec>;\n              sort: \"asc\" | \"desc\";\n            }[];\n          };\n          columnVisibility?: {\n            hiddenColIds: CanonicalizedJson<PTableColumnSpec>[];\n          };\n        };\n        sheetsState: PlDataTableSheetState[];\n        filtersState: PlDataTableFilterState[];\n      }[];\n      pTableParams: PTableParamsV2V7;\n    }\n  | {\n      version: 4;\n      stateCache: {\n        sourceId: string;\n        gridState: PlDataTableGridStateV6;\n        sheetsState: PlDataTableSheetState[];\n        filtersState: PlDataTableFilterState[];\n      }[];\n      /** Old format; only fields used in migration are typed */\n      pTableParams: {\n        sourceId: string | null;\n        hiddenColIds: PObjectId[] | null;\n        sorting: PTableSorting[];\n      };\n    }\n  // v5 stored colIds as `{source, labeled}` wrappers; only the gridState shape differs.\n  | {\n      version: 5;\n      stateCache: {\n        sourceId: string;\n        gridState: PlDataTableGridStateV5;\n        sheetsState: PlDataTableSheetState[];\n        filtersState: null | PlDataTableFiltersWithMetaV7;\n        defaultFiltersState: null | PlDataTableFiltersWithMetaV7;\n        searchString?: string;\n      }[];\n      pTableParams: PTableParamsV2V7;\n    }\n  // v6 stored colIds as canonicalized full `PTableColumnSpec` (including\n  // annotations + `pl7.app/trace`). v7 strips down to `PTableColumnId`.\n  | PlDataTableStateV2V6\n  // v7 still had filter leaves serialised as `CanonicalizedJson<PTableColumnId>`\n  // strings and `sorting: []` for the \"untouched\" case.\n  | PlDataTableStateV2V7\n  // v8 may still hold column ids written before the column-access rework (see\n  // `upgradeLegacyColumnId`).\n  | PlDataTableStateV2V8\n  // v9 as stored before the model read the source's entry itself, with that\n  // entry's settings also translated into pTableParams.\n  | PlDataTableStateV2V9\n  // Normalized state\n  | PlDataTableStateV2Normalized;\n\n/** v8 state: column ids not yet checked for the pre-rework form. */\nexport type PlDataTableStateV2V8 = StoredStateV8<8>;\n\n/** v9 state as stored before the model read the source's entry itself. */\nexport type PlDataTableStateV2V9 = StoredStateV8<9>;\n\n/**\n * The v8 shape as SDK versions before the model read the source's entry itself\n * stored it: `pTableParams` also holds that entry's settings as table parameters.\n */\ntype StoredStateV8<V extends 8 | 9> = {\n  version: V;\n  stateCache: StoredCacheEntry[];\n  pTableParams: StoredPTableParams;\n};\n\ntype StoredPTableParams =\n  | {\n      sourceId: null;\n      hiddenColIds: null;\n      sorting: null;\n      filters: null;\n      defaultFilters: null;\n    }\n  | {\n      sourceId: string;\n      hiddenColIds: null | PTableColumnId[];\n      sorting: null | PTableSorting[];\n      filters: null | PlDataTableFilters;\n      defaultFilters: null | PlDataTableFilters;\n    };\n\n/** Upgrade PlDataTableStateV2 to the latest version */\nexport function upgradePlDataTableStateV2(\n  state: PlDataTableStateV2 | undefined,\n): PlDataTableStateV2Normalized {\n  // Block just added, had no state, model started earlier than the UI\n  if (!state) {\n    return createPlDataTableStateV2();\n  }\n  // v1 -> v2\n  if (!(\"version\" in state)) {\n    // Non upgradeable as sourceId calculation algorithm has changed, resetting state to default\n    state = createPlDataTableStateV2();\n  }\n  // v2 -> v3\n  if (state.version === 2) {\n    state = {\n      version: 3,\n      stateCache: state.stateCache.map((entry) => ({\n        ...entry,\n        filtersState: [],\n      })),\n      pTableParams: createDefaultPTableParamsV7(),\n    };\n  }\n  // v3 -> v4\n  if (state.version === 3) {\n    // Non upgradeable as column ids calculation algorithm has changed, resetting state to default\n    state = createPlDataTableStateV2();\n  }\n  // v4 -> v6: migrate per-column filters to tree-based format (skips v5).\n  // v4 gridState already used bare PTableColumnSpec colIds, so we jump\n  // straight to v6 without going through the v5 wrapper format.\n  if (state.version === 4) {\n    state = migrateV4toV6(state);\n  }\n  // v5 -> v6: unwrap `{source, labeled}` colIds in gridState.\n  if (state.version === 5) {\n    state = migrateV5toV6(state);\n  }\n  // v6 -> v7: shrink colIds from full PTableColumnSpec to PTableColumnId.\n  if (state.version === 6) {\n    state = migrateV6toV7(state);\n  }\n  // v7 -> v8: parse CanonicalizedJson<PTableColumnId> filter leaves into object\n  // form; translate `sorting: []` into `sorting: null`.\n  if (state.version === 7) {\n    state = migrateV7toV8(state);\n  }\n  // v8 -> v9: rewrite column ids written before the column-access rework.\n  if (state.version === 8) {\n    state = migrateV8toV9(state);\n  }\n  return adoptLegacyTableParams(state);\n}\n\n/**\n * Earlier SDK versions kept the sorting and hidden columns of the source on\n * screen only in `pTableParams`, next to the pointer to that source. They move\n * into that source's entry, other entries start untouched, and `pTableParams`\n * keeps only the pointer.\n */\nfunction adoptLegacyTableParams(\n  state: PlDataTableStateV2V9 | PlDataTableStateV2Normalized,\n): PlDataTableStateV2Normalized {\n  const legacy: StoredPTableParams = state.pTableParams;\n  const stateCache: StoredCacheEntry[] = state.stateCache;\n  return {\n    version: 9,\n    stateCache: stateCache.map((entry) => {\n      const isShown = entry.sourceId === legacy.sourceId;\n      return {\n        ...entry,\n        sorting: entry.sorting !== undefined ? entry.sorting : isShown ? legacy.sorting : null,\n        hiddenColIds:\n          entry.hiddenColIds !== undefined\n            ? entry.hiddenColIds\n            : isShown\n              ? legacy.hiddenColIds\n              : null,\n      };\n    }),\n    pTableParams: { ...createDefaultPTableParams(), sourceId: legacy.sourceId },\n  };\n}\n\n/** A cache entry as stored, possibly by an SDK version without the sorting fields. */\ntype StoredCacheEntry = Omit<PlDataTableStateV2CacheEntry, \"sorting\" | \"hiddenColIds\"> &\n  Partial<Pick<PlDataTableStateV2CacheEntry, \"sorting\" | \"hiddenColIds\">>;\n\n/** Migrate v5 to v6: unwrap `{source, labeled}` colIds in gridState. */\nfunction migrateV5toV6(state: Extract<PlDataTableStateV2, { version: 5 }>): PlDataTableStateV2V6 {\n  // pTableParams reset: v5 stored ColumnDiscoveredId-based hiddenColIds with\n  // empty-array fields (e.g. `{column, path: [], columnQualifications: [], ...}`).\n  // v6 distills empty fields, so the same logical column serialises differently\n  // and lookups would silently miss every previously-hidden discovered column.\n  // gridState colIds are derived from PTableColumnSpec and unaffected.\n  return {\n    version: 6,\n    stateCache: state.stateCache.map((entry) => ({\n      ...entry,\n      gridState: unwrapV5GridState(entry.gridState),\n    })),\n    pTableParams: createDefaultPTableParamsV7(),\n  };\n}\n\n/** Convert v5 wrapped colId JSON to bare PTableColumnSpec JSON, taking `.source`.\n * gridState colIds may include the row-number sentinel (a JSON-stringified\n * literal, not a wrapped spec) — those pass through unchanged. */\nfunction unwrapV5ColId(json: string): string {\n  const parsed: unknown = parseJsonSafely(json as CanonicalizedJson<unknown>);\n  return !isNil(parsed) && typeof parsed === \"object\" && \"source\" in parsed\n    ? canonicalizeJson((parsed as PlDataTableV5ColIdWrapper).source)\n    : json;\n}\n\nfunction unwrapV5GridState(gridState: PlDataTableGridStateV5): PlDataTableGridStateV6 {\n  const unwrapAs = (json: PlDataTableV5ColIdJson) => unwrapV5ColId(json) as PlDataTableV6ColIdJson;\n  return {\n    columnOrder: gridState.columnOrder\n      ? { orderedColIds: gridState.columnOrder.orderedColIds.map(unwrapAs) }\n      : undefined,\n    sort: gridState.sort\n      ? {\n          sortModel: gridState.sort.sortModel.map((s) => ({\n            colId: unwrapAs(s.colId),\n            sort: s.sort,\n          })),\n        }\n      : undefined,\n    columnVisibility: gridState.columnVisibility\n      ? { hiddenColIds: gridState.columnVisibility.hiddenColIds.map(unwrapAs) }\n      : undefined,\n  };\n}\n\n/** Migrate v6 to v7: rewrite each colId from a full PTableColumnSpec to its\n * compact PTableColumnId (drops annotations/spec body, ~16× smaller per column). */\nfunction migrateV6toV7(state: PlDataTableStateV2V6): PlDataTableStateV2V7 {\n  return {\n    version: 7,\n    stateCache: state.stateCache.map((entry): PlDataTableStateV2V7CacheEntry => ({\n      ...entry,\n      gridState: shrinkV6GridState(entry.gridState),\n    })),\n    pTableParams: state.pTableParams,\n  };\n}\n\n/** Convert a v6 fat colId (canonicalized PTableColumnSpec) to a v7 compact colId\n * (canonicalized PTableColumnId). The row-number sentinel is a string literal,\n * not a spec — pass it through unchanged. */\nfunction shrinkV6ColId(json: PlDataTableV6ColIdJson): PlTableColumnIdJson {\n  const parsed: unknown = parseJsonSafely(json);\n  if (!isNil(parsed) && typeof parsed === \"object\" && \"type\" in parsed && \"id\" in parsed) {\n    return canonicalizeJson(getPTableColumnId(parsed as PTableColumnSpec));\n  }\n  return json as unknown as PlTableColumnIdJson;\n}\n\nfunction shrinkV6GridState(gridState: PlDataTableGridStateV6): PlDataTableGridStateCoreV7 {\n  return {\n    columnOrder: gridState.columnOrder\n      ? { orderedColIds: gridState.columnOrder.orderedColIds.map(shrinkV6ColId) }\n      : undefined,\n    sort: gridState.sort\n      ? {\n          sortModel: gridState.sort.sortModel.map((s) => ({\n            colId: shrinkV6ColId(s.colId),\n            sort: s.sort,\n          })),\n        }\n      : undefined,\n    columnVisibility: gridState.columnVisibility\n      ? { hiddenColIds: gridState.columnVisibility.hiddenColIds.map(shrinkV6ColId) }\n      : undefined,\n  };\n}\n\n/** Migrate v4 state to v6: convert per-column filters to tree-based format (skips v5). */\nfunction migrateV4toV6(state: Extract<PlDataTableStateV2, { version: 4 }>): PlDataTableStateV2V6 {\n  let idCounter = 0;\n  const nextId = () => ++idCounter;\n\n  const migratedCache: PlDataTableStateV2V6CacheEntry[] = state.stateCache.map((entry) => {\n    const leaves: PlDataTableFiltersWithMetaV7[\"filters\"] = [];\n    for (const f of entry.filtersState) {\n      if (f.filter !== null && !f.filter.disabled) {\n        leaves.push(migrateTableFilter(canonicalizeJson(f.id), f.filter.value, nextId));\n      }\n    }\n    const filtersState: PlDataTableFiltersWithMetaV7 | null =\n      leaves.length > 0 ? { id: nextId(), type: \"and\", filters: leaves } : null;\n\n    return {\n      sourceId: entry.sourceId,\n      gridState: entry.gridState,\n      sheetsState: entry.sheetsState,\n      filtersState,\n      defaultFiltersState: null,\n    };\n  });\n\n  const oldSourceId = state.pTableParams.sourceId;\n  const currentCache = oldSourceId\n    ? migratedCache.find((e) => e.sourceId === oldSourceId)\n    : undefined;\n\n  return {\n    version: 6,\n    stateCache: migratedCache,\n    pTableParams:\n      currentCache && oldSourceId\n        ? {\n            sourceId: oldSourceId,\n            hiddenColIds:\n              state.pTableParams.hiddenColIds?.map((id) => ({ type: \"column\" as const, id })) ??\n              null,\n            filters: distillFilterSpec(currentCache.filtersState),\n            defaultFilters: null,\n            sorting: state.pTableParams.sorting,\n          }\n        : createDefaultPTableParamsV7(),\n  };\n}\n\n/** Migrate a single per-column PlTableFilter to a v7-form tree node (legacy\n *  string column ids). v7 → v8 later converts these to object form. */\nfunction migrateTableFilter(\n  column: CanonicalizedJson<PTableColumnId>,\n  filter: PlTableFilter,\n  nextId: () => number,\n): PlDataTableFiltersWithMetaV7[\"filters\"][number] {\n  const id = nextId();\n  switch (filter.type) {\n    case \"isNA\":\n      return { id, type: \"isNA\", column };\n    case \"isNotNA\":\n      return { id, type: \"isNotNA\", column };\n    case \"number_equals\":\n      return { id, type: \"equal\", column, x: filter.reference };\n    case \"number_notEquals\":\n      return { id, type: \"notEqual\", column, x: filter.reference };\n    case \"number_greaterThan\":\n      return { id, type: \"greaterThan\", column, x: filter.reference };\n    case \"number_greaterThanOrEqualTo\":\n      return { id, type: \"greaterThanOrEqual\", column, x: filter.reference };\n    case \"number_lessThan\":\n      return { id, type: \"lessThan\", column, x: filter.reference };\n    case \"number_lessThanOrEqualTo\":\n      return { id, type: \"lessThanOrEqual\", column, x: filter.reference };\n    case \"number_between\":\n      return {\n        id,\n        type: \"and\",\n        filters: [\n          filter.includeLowerBound\n            ? { id: nextId(), type: \"greaterThanOrEqual\" as const, column, x: filter.lowerBound }\n            : { id: nextId(), type: \"greaterThan\" as const, column, x: filter.lowerBound },\n          filter.includeUpperBound\n            ? { id: nextId(), type: \"lessThanOrEqual\" as const, column, x: filter.upperBound }\n            : { id: nextId(), type: \"lessThan\" as const, column, x: filter.upperBound },\n        ],\n      };\n    case \"string_equals\":\n      return { id, type: \"patternEquals\", column, value: filter.reference };\n    case \"string_notEquals\":\n      return { id, type: \"patternNotEquals\", column, value: filter.reference };\n    case \"string_contains\":\n      return { id, type: \"patternContainSubsequence\", column, value: filter.reference };\n    case \"string_doesNotContain\":\n      return { id, type: \"patternNotContainSubsequence\", column, value: filter.reference };\n    case \"string_matches\":\n      return { id, type: \"patternMatchesRegularExpression\", column, value: filter.reference };\n    case \"string_doesNotMatch\":\n      return {\n        id,\n        type: \"not\",\n        filter: {\n          id: nextId(),\n          type: \"patternMatchesRegularExpression\",\n          column,\n          value: filter.reference,\n        },\n      };\n    case \"string_containsFuzzyMatch\":\n      return {\n        id,\n        type: \"patternFuzzyContainSubsequence\",\n        column,\n        value: filter.reference,\n        maxEdits: filter.maxEdits,\n        substitutionsOnly: filter.substitutionsOnly,\n        ...(filter.wildcard !== undefined ? { wildcard: filter.wildcard } : {}),\n      };\n  }\n}\n\n/** Default pTableParams in the v7 shape (sorting: []). Used by intermediate\n *  migration steps that produce v6/v7 state before the v7 → v8 conversion. */\nfunction createDefaultPTableParamsV7(): PTableParamsV2V7 {\n  return {\n    sourceId: null,\n    hiddenColIds: null,\n    filters: null,\n    defaultFilters: null,\n    sorting: [],\n  };\n}\n\nexport function createDefaultPTableParams(): PTableParamsV2 {\n  return {\n    sourceId: null,\n    hiddenColIds: null,\n    filters: null,\n    defaultFilters: null,\n    sorting: null,\n  };\n}\n\nexport function createPlDataTableStateV2(): PlDataTableStateV2Normalized {\n  return {\n    version: 9,\n    stateCache: [],\n    pTableParams: createDefaultPTableParams(),\n  };\n}\n\n// --- v7 -> v8 migration ----------------------------------------------------\n// Parses CanonicalizedJson<PTableColumnId> filter leaves into the new object\n// form. Malformed leaves are dropped; groups that become empty after pruning\n// are dropped; cache entries whose tree fully prunes get filtersState: null.\n// Also translates `sorting: []` (legacy \"untouched\") into `sorting: null`.\n\nfunction migrateV7toV8(state: PlDataTableStateV2V7): PlDataTableStateV2V8 {\n  const newCache: StoredCacheEntry[] = state.stateCache.map((entry) => ({\n    sourceId: entry.sourceId,\n    gridState: entry.gridState,\n    sheetsState: entry.sheetsState,\n    filtersState: convertFiltersWithMeta(entry.filtersState),\n    defaultFiltersState: convertFiltersWithMeta(entry.defaultFiltersState),\n    searchString: entry.searchString,\n  }));\n\n  const params = state.pTableParams;\n  let pTableParams: StoredPTableParams;\n  if (params.sourceId === null) {\n    pTableParams = createDefaultPTableParams();\n  } else {\n    pTableParams = {\n      sourceId: params.sourceId,\n      hiddenColIds: params.hiddenColIds,\n      // Empty array in legacy state means \"not touched\" — translate to null so the\n      // model falls back to default sorting; non-empty stays as user's explicit value.\n      sorting: params.sorting.length === 0 ? null : params.sorting,\n      filters: convertFiltersPlain(params.filters),\n      defaultFilters: convertFiltersPlain(params.defaultFilters),\n    };\n  }\n\n  return { version: 8, stateCache: newCache, pTableParams };\n}\n\nfunction convertFiltersWithMeta(\n  node: null | PlDataTableFiltersWithMetaV7,\n): null | PlDataTableFiltersWithMeta {\n  if (node === null) return null;\n  const result = pruneFilterNode(node as unknown);\n  if (result === undefined) return null;\n  return result as PlDataTableFiltersWithMeta;\n}\n\nfunction convertFiltersPlain(node: null | PlDataTableFiltersV7): null | PlDataTableFilters {\n  if (node === null) return null;\n  const result = pruneFilterNode(node as unknown);\n  if (result === undefined) return null;\n  return result as PlDataTableFilters;\n}\n\n/** Recursively converts and prunes a legacy v7 filter tree. Preserves meta\n *  fields (id/isExpanded/source/isSuppressed) on non-leaf nodes. Returns\n *  `undefined` when the subtree is empty after pruning. */\nfunction pruneFilterNode(node: unknown): unknown | undefined {\n  if (!node || typeof node !== \"object\") return undefined;\n  const n = node as { type?: unknown };\n  if (n.type === \"and\" || n.type === \"or\") {\n    const filters = (n as { filters?: unknown[] }).filters ?? [];\n    const kept = filters.map((f) => pruneFilterNode(f)).filter((f): f is object => f !== undefined);\n    if (kept.length === 0) return undefined;\n    return { ...(n as object), type: n.type, filters: kept };\n  }\n  if (n.type === \"not\") {\n    const inner = pruneFilterNode((n as { filter?: unknown }).filter);\n    if (inner === undefined) return undefined;\n    return { ...(n as object), type: \"not\", filter: inner };\n  }\n  return convertLegacyLeaf(n);\n}\n\nfunction convertLegacyLeaf(leaf: {\n  type?: unknown;\n  column?: unknown;\n  rhs?: unknown;\n}): unknown | undefined {\n  if (leaf.type === undefined) return leaf;\n  const result: Record<string, unknown> = { ...leaf };\n  if (\"column\" in result) {\n    const c = parseLegacyLeafColumn(result.column);\n    if (c === undefined) return undefined;\n    result.column = c;\n  }\n  if (\"rhs\" in result) {\n    const c = parseLegacyLeafColumn(result.rhs);\n    if (c === undefined) return undefined;\n    result.rhs = c;\n  }\n  return result;\n}\n\nfunction parseLegacyLeafColumn(s: unknown): PTableColumnId | undefined {\n  if (typeof s !== \"string\") return undefined;\n  const parsed = parseJsonSafely(s as CanonicalizedJson<PTableColumnId>);\n  if (!parsed || typeof parsed !== \"object\") return undefined;\n  if (!(\"type\" in parsed) || !(\"id\" in parsed)) return undefined;\n  const t = (parsed as { type: unknown }).type;\n  if (t !== \"axis\" && t !== \"column\") return undefined;\n  return parsed as PTableColumnId;\n}\n\n// --- v8 -> v9 migration ----------------------------------------------------\n// The column-access rework (July 2026) marked discovered column ids with\n// `__isDiscovered`. Ids saved before it — user sorting, hidden columns, column\n// order, filter leaves — came through the v6 -> v8 steps unchanged, and the\n// current id parser rejects them. Legacy discovered ids are rewritten to the\n// current form, so the user's choices survive. Legacy anchored and filtered\n// ids name a column relative to an anchor the state does not hold; entries\n// using them are dropped.\n\nfunction migrateV8toV9(state: PlDataTableStateV2V8): PlDataTableStateV2V9 {\n  return {\n    version: 9,\n    stateCache: state.stateCache.map((entry): StoredCacheEntry => ({\n      ...entry,\n      gridState: upgradeGridStateColumnIds(entry.gridState),\n      filtersState: upgradeFilterColumnIds(entry.filtersState),\n      defaultFiltersState: upgradeFilterColumnIds(entry.defaultFiltersState),\n    })),\n    pTableParams: upgradeParamsColumnIds(state.pTableParams),\n  };\n}\n\n/** Keys a pre-rework discovered column id could carry; it had no marker. */\nconst LEGACY_DISCOVERED_KEYS = new Set([\n  \"column\",\n  \"path\",\n  \"columnQualifications\",\n  \"queriesQualifications\",\n]);\n\ntype LegacyDiscoveredKey = {\n  column: string;\n  path?: { type: \"linker\"; column: string }[];\n  columnQualifications?: AxisQualification[];\n  queriesQualifications?: Record<PObjectId, AxisQualification[]>;\n};\n\nfunction isLegacyDiscoveredKey(value: unknown): value is LegacyDiscoveredKey {\n  if (typeof value !== \"object\" || value === null || Array.isArray(value)) return false;\n  if (!Object.keys(value).every((key) => LEGACY_DISCOVERED_KEYS.has(key))) return false;\n  const { column, path } = value as { column?: unknown; path?: unknown };\n  if (typeof column !== \"string\") return false;\n  if (path === undefined) return true;\n  return (\n    Array.isArray(path) &&\n    path.every(\n      (item: unknown) =>\n        typeof item === \"object\" &&\n        item !== null &&\n        (item as { type?: unknown }).type === \"linker\" &&\n        typeof (item as { column?: unknown }).column === \"string\",\n    )\n  );\n}\n\n/**\n * A stored column id in its current form: unchanged when already current,\n * rewritten when it is a pre-rework discovered id, `undefined` when it cannot be\n * carried over (a pre-rework anchored or filtered id, or not an id at all).\n */\nexport function upgradeLegacyColumnId(id: string): ColumnUniversalId | undefined {\n  const key: unknown = parseJsonSafely(id);\n  if (isColumnUniversalKey(key)) return id as ColumnUniversalId;\n  if (!isLegacyDiscoveredKey(key)) return undefined;\n\n  const column = upgradeLegacyColumnId(key.column);\n  if (column === undefined) return undefined;\n  const path: { type: \"linker\"; column: ColumnUniversalId }[] = [];\n  for (const item of key.path ?? []) {\n    const linker = upgradeLegacyColumnId(item.column);\n    if (linker === undefined) return undefined;\n    path.push({ type: \"linker\", column: linker });\n  }\n  // Discovery names a hit reached with no linker and no qualifications by its own id\n  // and wraps only the rest; the pre-rework form wrapped every hit.\n  const hasQualifications =\n    (key.columnQualifications?.length ?? 0) > 0 ||\n    Object.keys(key.queriesQualifications ?? {}).length > 0;\n  if (path.length === 0 && !hasQualifications) return column;\n  return stringifyColumnDiscoveredId({\n    column,\n    path,\n    columnQualifications: key.columnQualifications,\n    queriesQualifications: key.queriesQualifications,\n  });\n}\n\nfunction upgradeColumnRef(ref: PTableColumnId): PTableColumnId | undefined {\n  if (ref.type !== \"column\") return ref;\n  const id = upgradeLegacyColumnId(ref.id);\n  return id === undefined ? undefined : { type: \"column\", id };\n}\n\nfunction upgradeParamsColumnIds(params: StoredPTableParams): StoredPTableParams {\n  if (params.sourceId === null) return params;\n\n  const hiddenColIds =\n    params.hiddenColIds === null\n      ? null\n      : params.hiddenColIds.flatMap((ref) => upgradeColumnRef(ref) ?? []);\n\n  return {\n    ...params,\n    hiddenColIds,\n    sorting: params.sorting === null ? null : upgradeSorting(params.sorting),\n    filters: upgradeFilterColumnIds(params.filters),\n    defaultFilters: upgradeFilterColumnIds(params.defaultFilters),\n  };\n}\n\n/** `[]` is the user's cleared sorting and stays. A sorting emptied by dropped\n *  entries falls back to the default (`null`) instead of reading as cleared. */\nfunction upgradeSorting(sorting: PTableSorting[]): null | PTableSorting[] {\n  if (sorting.length === 0) return sorting;\n  const kept = sorting.flatMap((entry): PTableSorting[] => {\n    const column = upgradeColumnRef(entry.column);\n    return column === undefined ? [] : [{ ...entry, column }];\n  });\n  return kept.length === 0 ? null : kept;\n}\n\nfunction upgradeGridColId(colId: PlTableColumnIdJsonV8): PlTableColumnIdJsonV8 | undefined {\n  const parsed: unknown = parseJsonSafely(colId);\n  // Not a column id: the row-number sentinel passes through unchanged.\n  if (typeof parsed !== \"object\" || parsed === null || !(\"type\" in parsed) || !(\"id\" in parsed)) {\n    return colId;\n  }\n  const ref = upgradeColumnRef(parsed as PTableColumnId);\n  if (ref === undefined) return undefined;\n  return ref === parsed ? colId : canonicalizeJson<PTableColumnId>(ref);\n}\n\nfunction upgradeGridStateColumnIds(gridState: PlDataTableGridStateCore): PlDataTableGridStateCore {\n  const upgradeAll = (colIds: PlTableColumnIdJsonV8[]) =>\n    colIds.flatMap((colId) => upgradeGridColId(colId) ?? []);\n  return {\n    ...gridState,\n    ...(gridState.columnOrder && {\n      columnOrder: { orderedColIds: upgradeAll(gridState.columnOrder.orderedColIds) },\n    }),\n    ...(gridState.sort && {\n      sort: {\n        sortModel: gridState.sort.sortModel.flatMap((s) => {\n          const colId = upgradeGridColId(s.colId);\n          return colId === undefined ? [] : [{ ...s, colId }];\n        }),\n      },\n    }),\n    ...(gridState.columnVisibility && {\n      columnVisibility: { hiddenColIds: upgradeAll(gridState.columnVisibility.hiddenColIds) },\n    }),\n  };\n}\n\nfunction upgradeFilterColumnIds<T extends PlDataTableFilters | PlDataTableFiltersWithMeta>(\n  node: null | T,\n): null | T {\n  if (node === null) return null;\n  const result = upgradeFilterNode(node);\n  return result === undefined ? null : (result as T);\n}\n\n/** Rewrites the column ids in a filter tree. A leaf whose id cannot be carried\n *  over is dropped, and a group left empty with it. */\nfunction upgradeFilterNode(node: unknown): unknown | undefined {\n  if (!node || typeof node !== \"object\") return undefined;\n  const n = node as { type?: unknown };\n  if (n.type === \"and\" || n.type === \"or\") {\n    const filters = (n as { filters?: unknown[] }).filters ?? [];\n    const kept = filters.map(upgradeFilterNode).filter((f): f is object => f !== undefined);\n    if (kept.length === 0) return undefined;\n    return { ...n, filters: kept };\n  }\n  if (n.type === \"not\") {\n    const inner = upgradeFilterNode((n as { filter?: unknown }).filter);\n    return inner === undefined ? undefined : { ...n, filter: inner };\n  }\n  const leaf: Record<string, unknown> = { ...n };\n  for (const field of [\"column\", \"rhs\"]) {\n    if (!(field in leaf)) continue;\n    const ref = upgradeColumnRef(leaf[field] as PTableColumnId);\n    if (ref === undefined) return undefined;\n    leaf[field] = ref;\n  }\n  return leaf;\n}\n"],"mappings":"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"}