@evotecit/canopyx 0.0.0-stage → 0.1.0

package/JavaScript/hosts.d.ts

@@ -0,0 +1,109 @@
+import type {
+  CanopyNode, CanopyColumn, CanopyView, InlineView, SidecarView, RemoteView, CanopyLabels, CellValue, CheckIntent,
+  CountsDocument, PageResult, SearchResult, ViewQuery, ReadonlyViewQuery, ContextAction
+} from "./protocol.js";
+
+export type Awaitable<T> = T | PromiseLike<T>;
+/** Query-aware hosts answer from one accepted dataset revision. */
+export interface SourceRequest { signal: AbortSignal; query?: ReadonlyViewQuery; revision?: string | null; }
+interface DataSourceBase {
+  kind?: string;
+  /** Resolves a lease disposer. A source releases held data on cancellation as well. */
+  prefetch?(opens: string[], finds: string[], request?: SourceRequest): Awaitable<void | (() => void)>;
+}
+type SourcePage<T> = (node: CanopyNode | null, cursor: string | null, request?: SourceRequest) => Awaitable<T>;
+type SourceSearch<T> = (query: string, limit: number, request?: SourceRequest) => Awaitable<T>;
+type SourceCounts<T> = (ids: string[], request?: SourceRequest) => Awaitable<T>;
+type SearchCapability<T> = (
+  | { canSearch: true; search: SourceSearch<T> }
+  | { canSearch?: false; search?: SourceSearch<T> }
+);
+/** Search availability requires its method; query-aware callbacks identify one dataset revision. */
+export type DataSource = DataSourceBase & (
+  | ({ queryAware?: false; page: SourcePage<PageResult>; counts?: SourceCounts<CountsDocument> | null } & SearchCapability<SearchResult>)
+  | ({ queryAware: true; page: SourcePage<PageResult & { revision: string }>;
+       counts?: SourceCounts<CountsDocument & { revision: string }> | null } & SearchCapability<SearchResult & { revision: string }>)
+);
+export interface RemoteOptions { timeoutMs?: number; signal?: AbortSignal; }
+export interface Sources {
+  inline(view: InlineView): DataSource;
+  sidecar(view: SidecarView): DataSource;
+  remote(view: RemoteView, options?: RemoteOptions): DataSource;
+}
+
+export interface NodeReference { readonly nodeId: string; readonly path: readonly string[]; }
+export interface EditProposal extends NodeReference {
+  readonly column: string;
+  readonly previous: CellValue;
+  readonly value: CellValue;
+}
+export type DropPlacement = "inside" | "before" | "after";
+export interface DropProposal {
+  readonly nodes: readonly NodeReference[];
+  readonly target: { readonly nodeId: string | null; readonly path: readonly string[] };
+  readonly placement: DropPlacement;
+}
+export interface ActionProposal extends NodeReference { readonly action: string; }
+export interface InteractionContext {
+  readonly signal: AbortSignal;
+  readonly reason: string;
+  readonly query: ViewQuery | null;
+  readonly revision: string | null;
+}
+export interface InteractionOptions { signal?: AbortSignal; reason?: string; }
+export interface SelectionContext { previous: CanopyNode[]; reason: string; }
+export interface CheckContext { readonly previous: readonly CheckIntent[]; readonly reason: string; }
+export interface CellContext {
+  column: string; level: number; expanded: boolean; index: number;
+  /** Aborts before replacement, recycling, failed rendering or destruction. */
+  readonly signal: AbortSignal;
+  /** Registers cleanup for this cell paint. Called once in reverse registration order. */
+  onDispose(cleanup: () => void): void;
+}
+export interface LoadInfo { node: CanopyNode | null; count: number; total: number | null; ms: number; }
+
+/** Hooks stay with the host. Acceptance never makes the grid perform a write. */
+interface HostOptionsBase {
+  source?: DataSource;
+  labels?: CanopyLabels;
+  requestTimeoutMs?: number;
+  retainedNodeLimit?: number;
+  inactiveNodeLimit?: number;
+  interactionTimeoutMs?: number;
+  renderers?: Record<string, (node: CanopyNode, element: HTMLElement, context: CellContext) => boolean>;
+  renderDetail?: (node: CanopyNode, element: HTMLElement) => boolean;
+  onSelect?: (node: CanopyNode | null, nodes: CanopyNode[]) => void;
+  onToggle?: (node: CanopyNode, expanded: boolean) => void;
+  onLoad?: (node: CanopyNode | null, info: LoadInfo) => void;
+  isSelectable?: (node: CanopyNode) => boolean;
+  beforeSelect?: (node: CanopyNode | null, nodes: CanopyNode[], context: SelectionContext) => boolean | void;
+  isCheckable?: (node: CanopyNode) => boolean;
+  beforeCheck?: (node: CanopyNode | null, intents: readonly CheckIntent[], context: CheckContext) => boolean | void;
+  onCheck?: (node: CanopyNode | null, intents: readonly CheckIntent[], context: { reason: string }) => void;
+  onEdit?: (proposal: EditProposal, context: InteractionContext) => Awaitable<boolean>;
+  onDrop?: (proposal: DropProposal, context: InteractionContext) => Awaitable<boolean>;
+  onAction?: (proposal: ActionProposal, context: InteractionContext) => Awaitable<boolean>;
+  canEdit?: (node: CanopyNode, column: CanopyColumn) => boolean;
+  canDrag?: (node: CanopyNode) => boolean;
+  canDrop?: (proposal: DropProposal) => boolean;
+  isActionEnabled?: (node: CanopyNode, action: Readonly<ContextAction>) => boolean;
+}
+/** A custom deep-link scheme supplies its formatter and parser together. */
+export type HostOptions = HostOptionsBase & (
+  | { formatLink: (path: string[], node: CanopyNode | null) => string | null;
+      parseLink: (fragment: string) => Awaitable<string[] | null> }
+  | { formatLink?: never; parseLink?: never }
+);
+export type TreeGridOptions = HostOptions & { view: CanopyView };
+export interface ExpandPathOptions {
+  select?: boolean;
+  focus?: boolean;
+  reveal?: boolean;
+  expandLast?: boolean;
+  signal?: AbortSignal;
+}
+export interface FilterOptions { autoExpand?: boolean; }
+export type NodeFilter = ((node: CanopyNode) => boolean) | {
+  match(node: CanopyNode): boolean;
+  keep?(node: CanopyNode): boolean;
+};

package/JavaScript/index.d.ts

@@ -0,0 +1,85 @@
+import type {
+  CanopyBadge, CanopyNode, CanopyView, CanopyLabels, CellValue, CheckIntent, CheckState,
+  CountsDocument, SortDirection, TimeZone, ViewQuery, ViewState, LegacyViewState, SearchResult, LabelName
+} from "./protocol.js";
+import type {
+  TreeGridOptions, HostOptions, Sources, ExpandPathOptions, NodeFilter, FilterOptions,
+  InteractionOptions, DropPlacement
+} from "./hosts.js";
+export * from "./protocol.js";
+export * from "./hosts.js";
+
+/** One mounted grid. Every method owns presentation only; host hooks own domain writes. */
+export interface TreeGrid {
+  readonly element: HTMLElement;
+  readonly view: CanopyView;
+  readonly ready: Promise<void>;
+  expandPath(ids: string[], options?: ExpandPathOptions): Promise<CanopyNode | null>;
+  setFilter(filter: NodeFilter | null, options?: FilterOptions): void;
+  setFilterActive(id: string, active: boolean): void | Promise<boolean>;
+  setActiveFilters(ids: string[]): void | Promise<boolean>;
+  /** Applies removals, then additions, in one transaction using the latest pending query. */
+  updateActiveFilters(change: { add?: readonly string[]; remove?: readonly string[] }): void | Promise<boolean>;
+  getActiveFilters(): string[];
+  sort(columnId: string, direction?: SortDirection | null): void | Promise<boolean>;
+  getQuery(): ViewQuery;
+  setQuery(query: ViewQuery, options?: { signal?: AbortSignal }): Promise<boolean>;
+  setColumnVisible(columnId: string, visible: boolean): void;
+  setColumnWidth(columnId: string, width: number): void;
+  setTreeColumnPinned(pinned: boolean): void;
+  setTimeZone(zone: TimeZone): void;
+  getTimeZone(): TimeZone;
+  refresh(): void;
+  reload(id?: string | null, options?: { signal?: AbortSignal }): Promise<boolean>;
+  readLocation(): Promise<void>;
+  getSelected(): CanopyNode[];
+  /** Replaces selection with loaded IDs. Single-selection overflow is rejected atomically. */
+  setSelection(ids: string[]): boolean;
+  clearSelection(): boolean;
+  /** Chooses loaded or visible nodes without fetching unloaded data. Scope is required. */
+  selectAll(options: { scope: "visible" | "loaded" }): boolean;
+  focus(): void;
+  visibleRows(): { node: CanopyNode; level: number; path: string[] }[];
+  toOutline(): string;
+  getState(): ViewState;
+  setState(state: ViewState | LegacyViewState): Promise<boolean>;
+  search(query: string, limit?: number): Promise<SearchResult>;
+  loadMore(id?: string | null): Promise<void>;
+  applyCounts(document: CountsDocument): void;
+  refreshCounts(ids?: string[]): Promise<CountsDocument | null>;
+  getCheckState(id: string): CheckState | null;
+  getCheckIntents(): CheckIntent[];
+  setChecked(id: string, checked: boolean): boolean;
+  setCheckIntents(intents: readonly CheckIntent[]): boolean;
+  requestEdit(id: string, column: string, value: CellValue, options?: InteractionOptions): Promise<boolean>;
+  requestDrop(ids: string[], target: string | null, placement?: DropPlacement, options?: InteractionOptions): Promise<boolean>;
+  requestAction(id: string, action: string, options?: InteractionOptions): Promise<boolean>;
+  cancelInteraction(): boolean;
+  beginEdit(id: string, column: string): boolean;
+  openActions(id: string): boolean;
+  destroy(): void;
+}
+
+export const protocol: "canopyx/2";
+/** Creates a grid, or returns the existing grid mounted in this host. Requires a browser DOM. */
+export function createTreeGrid(host: HTMLElement, options: TreeGridOptions): TreeGrid;
+/** Configures future fragment mounts and returns a disposer for this registration. Requires a browser DOM. */
+export function configure(viewId: string, options: HostOptions): () => void;
+export function unconfigure(viewId: string): boolean;
+/** Mounts unmounted fragments below root. Requires a browser DOM. */
+export function mount(root?: ParentNode): TreeGrid[];
+export const sources: Readonly<Sources>;
+export function badge(value: CanopyBadge): HTMLElement;
+export const labels: Readonly<Record<LabelName, string>>;
+
+declare const CanopyX: Readonly<{
+  protocol: typeof protocol;
+  createTreeGrid: typeof createTreeGrid;
+  configure: typeof configure;
+  unconfigure: typeof unconfigure;
+  mount: typeof mount;
+  sources: typeof sources;
+  badge: typeof badge;
+  labels: typeof labels;
+}>;
+export default CanopyX;

package/JavaScript/locales/de.d.ts

@@ -0,0 +1,6 @@
+import type { CanopyLabels } from "../protocol.js";
+/** Complete German browser labels; individual properties can be overridden by the host. */
+export const labels: Readonly<Required<CanopyLabels>>;
+/** Labels used only by a script-free static fallback. */
+export const staticLabels: Readonly<{ overflowNote: string; unknownTotal: string; hiddenRows: string; fullReport: string }>;
+export default labels;

package/JavaScript/locales/de.mjs

@@ -0,0 +1,223 @@
+// Generated from CanopyX/Views/Locales/labels.json by Build/Sync-Assets.ps1.
+const labels = Object.freeze({
+  searchPlaceholder: "Suchen",
+  searchResults: "Suchergebnisse",
+  searchResultCount: "{count} Ergebnisse",
+  searchResultCountOfTotal: "{count} von {total} Ergebnissen",
+  searchResultCountOfMany: "{count} von vielen Ergebnissen",
+  searchNoResults: "Keine Ergebnisse",
+  searchTooShort: "Mindestens {min} Zeichen eingeben",
+  searchWordTooShort: "Ein Wort mit mindestens {min} Zeichen eingeben",
+  searchFailed: "Suche fehlgeschlagen: {error}",
+  columns: "Spalten",
+  gridFilters: "Filter",
+  gridFitContent: "An Inhalt anpassen",
+  gridUnpin: "Fixierung aufheben",
+  gridWhere: "Wenn",
+  gridComplexFilter: "Diese Spalte gehört zu einer gemischten Bedingungsgruppe. Bearbeiten Sie sie unter Filter.",
+  gridClearColumnFilter: "Filter löschen",
+  gridSelectionAggregate: "Anzahl: {count} · Summe: {sum} · Durchschnitt: {average} · Minimum: {minimum} · Maximum: {maximum}",
+  gridConditionValue: "Wert",
+  gridConditionUpperValue: "Oberer Wert",
+  gridDeleteCondition: "Bedingung entfernen",
+  gridShowRowsWhere: "Zeilen anzeigen, für die",
+  gridOfTheseAreTrue: "dieser Bedingungen zutreffen",
+  gridOfThese: "dieser Bedingungen",
+  gridGroupCount: "{count} Gruppen",
+  gridMore: "Mehr",
+  gridDone: "Fertig",
+  gridClearAll: "Alles löschen",
+  gridRows: "Zeilen",
+  gridResultNoun: "{count} von {total} {noun}",
+  gridSearchNoun: "{noun} suchen",
+  gridChart: "Diagramm",
+  gridColumnMenu: "Menü für {column}",
+  gridSortAscending: "Aufsteigend sortieren",
+  gridSortDescending: "Absteigend sortieren",
+  gridClearSort: "Sortierung löschen",
+  gridFilterColumn: "Filtern…",
+  gridHideColumn: "Spalte ausblenden",
+  gridGroupedBy: "Gruppiert nach",
+  gridRemoveGrouping: "Gruppierung entfernen",
+  gridSelectAllValues: "Alle Werte auswählen",
+  gridFilterValues: "Werte suchen",
+  gridAddCondition: "+ Bedingung",
+  gridAddGroup: "+ Gruppe",
+  gridAnd: "und",
+  gridOr: "oder",
+  gridEditAsText: "Als Text bearbeiten",
+  gridFilterText: "Filterausdruck",
+  gridDeepFilters: "Dieser gespeicherte Filter hat mehr als zwei Verschachtelungsebenen.",
+  gridToday: "Heute",
+  gridYesterday: "Gestern",
+  gridLastSevenDays: "Letzte 7 Tage",
+  gridLastThirtyDays: "Letzte 30 Tage",
+  gridThisMonth: "Dieser Monat",
+  gridDateRange: "Zeitraum",
+  gridEmpty: "Keine {noun}",
+  gridEmptyReason: "Es gibt keine Datensätze zum Anzeigen.",
+  gridNoMatches: "Keine passenden {noun}",
+  gridNoMatchesReason: "Suche: {search}. Aktive Filter: {count}.",
+  gridRetry: "Erneut versuchen",
+  gridLoadFailed: "Datensätze konnten nicht geladen werden",
+  gridAll: "Alle",
+  gridPageOf: "{page} von {pages}",
+  gridStatusCount: "{count} {noun} · {selected} ausgewählt",
+  gridDetailsSection: "Details",
+  gridPreviousRecord: "Vorheriger Datensatz",
+  gridNextRecord: "Nächster Datensatz",
+  gridShowMore: "Mehr anzeigen",
+  gridNoData: "Keine Daten",
+  gridPeriodRange: "{from}–{to}: {state}",
+  gridHealthy: "Normal",
+  gridResultCount: "{count} von {total} Zeilen",
+  gridUnknownCount: "Ergebnisanzahl nicht verfügbar",
+  gridMatchedCount: "{count} passende Zeilen",
+  gridCursorRange: "Zeilen {first}–{last}",
+  gridPaging: "Ergebnisseiten",
+  gridPageRange: "Zeilen {first}–{last} von {count}",
+  gridPageNumber: "Seite",
+  gridPageLength: "Zeilen pro Seite",
+  gridFirstPage: "Erste Seite",
+  gridPreviousPage: "Vorherige Seite",
+  gridNextPage: "Nächste Seite",
+  gridLastPage: "Letzte Seite",
+  gridClearQuery: "Suche und Filter löschen",
+  gridRemoveSearch: "Suche löschen: {search}",
+  gridGroupedFilters: "Filtergruppen ({count} Bedingungen)",
+  gridRemoveGroup: "Filtergruppen löschen",
+  gridRemoveCondition: "Bedingung entfernen: {condition}",
+  gridExport: "Exportieren",
+  gridFilteredResults: "Gefilterte Ergebnisse",
+  gridSelectedRows: "Ausgewählte Zeilen",
+  gridAllResults: "Alle Ergebnisse",
+  gridDownloadCsv: "CSV herunterladen",
+  gridCopy: "Kopieren",
+  gridDetails: "Datensatzdetails",
+  gridColumn: "Spalte",
+  gridOperator: "Bedingung",
+  gridValue: "Wert (Datumsangaben in UTC)",
+  gridValueType: "Typ des Rohwerts",
+  gridText: "Text",
+  gridBoolean: "Boolescher Wert",
+  gridAddFilter: "Filter hinzufügen",
+  gridRemoveFilter: "Filter für {column} entfernen",
+  gridApply: "Übernehmen",
+  gridClearFilters: "Alle Filter löschen",
+  gridMoveEarlier: "{column} nach links verschieben",
+  gridMoveLater: "{column} nach rechts verschieben",
+  gridViews: "Ansichten",
+  gridViewName: "Ansichtsname",
+  gridSaveView: "Ansicht speichern",
+  gridRemoveView: "Ansicht löschen",
+  gridResetView: "Ansicht zurücksetzen",
+  gridChooseView: "Gespeicherte Ansicht auswählen",
+  gridInvalidFilter: "Einen gültigen Filterwert eingeben.",
+  gridBetween: "zwischen (einschließlich)",
+  gridRangeEnd: "Oberer Wert (Datumsangaben in UTC)",
+  gridInvalidRange: "Der obere Wert muss mindestens so groß wie der untere Wert sein.",
+  gridSuggestedCategory: "Vorgeschlagene Kategorie",
+  gridChooseCategory: "Kategorie auswählen",
+  gridBooleanValue: "Boolescher Wert",
+  gridTrue: "Wahr",
+  gridFalse: "Falsch",
+  gridHeaderFilter: "{column} filtern",
+  gridExpandCell: "{column}: vollständigen Text anzeigen",
+  gridCloseCell: "Vollständigen Text schließen",
+  gridMoveColumn: "{column}: zum Verschieben ziehen oder Pfeil links/rechts verwenden",
+  gridResizeHelp: "Eingabe passt die Breite an bis zu 200 geladene Zeilen an; Pfeil links/rechts ändert die Breite.",
+  gridFitColumn: "{column} anpassen",
+  gridFitAllColumns: "Alle Spalten anpassen",
+  gridColumnMoved: "{column} an Position {position} verschoben",
+  gridPinColumn: "{column}: Spalte fixieren",
+  gridPinNone: "Mitlaufend",
+  gridPinLeft: "Links fixieren",
+  gridPinRight: "Rechts fixieren",
+  gridResponsiveHidden: "Bei dieser Breite ausgeblendet",
+  gridFindColumn: "Spalte suchen…",
+  gridShowAllColumns: "Alle anzeigen",
+  gridResetColumns: "Spalten zurücksetzen",
+  gridReorderColumn: "{column}: ziehen oder Alt+Pfeil nach oben bzw. Alt+Pfeil nach unten drücken, um zu verschieben",
+  gridPinnedLeft: "Links fixiert",
+  gridPinnedRight: "Rechts fixiert",
+  gridFilterGroupTitle: "Zusätzliche Bedingungsgruppen",
+  gridFilterMatch: "Übereinstimmung",
+  gridFilterAll: "Alle",
+  gridFilterAny: "Beliebige",
+  gridAddFilterGroup: "Bedingungsgruppe hinzufügen",
+  gridDeleteFilterGroup: "Bedingungsgruppe entfernen",
+  gridFacetValues: "Werte und Häufigkeiten mit angewendeten Filtern",
+  gridFacetSearch: "Werte suchen",
+  gridFacetIncludeCurrent: "Angewendete Filter dieser Spalte berücksichtigen",
+  gridFacetLoad: "Werte laden",
+  gridFacetChoose: "Wert auswählen",
+  gridFacetCounts: "{count} passende Zeilen; {shown} von {total} Werten.",
+  gridFacetReload: "Die Werte wurden geändert oder die Anfrage wurde abgebrochen. Werte erneut laden.",
+  gridRenameView: "Ansicht umbenennen",
+  gridDefaultView: "Als Standard festlegen",
+  gridClearDefaultView: "Standardzuordnung entfernen",
+  gridDefaultViewName: "Standardansicht: {name}",
+  gridNoDefaultView: "Keine Standardansicht",
+  gridDefaultViewOption: "{name} (Standard)",
+  gridSelection: "Auswahl",
+  gridSelectPage: "Seite auswählen",
+  gridSelectMatching: "Alle passenden auswählen",
+  gridClearSelection: "Auswahl aufheben",
+  gridSelectionCount: "{count} ausgewählt",
+  gridSelectionQueryCount: "{count} passende Datensätze ausgewählt; {excluded} ausgeschlossen",
+  gridSelectionQueryUnknown: "Alle passenden Datensätze ausgewählt; {excluded} ausgeschlossen",
+  gridSelectRecord: "Datensatz {id} auswählen",
+  gridGroupHeading: "{column}: {value} ({count} Datensätze)",
+  gridGroupMissing: "Fehlender Wert",
+  gridGroupExpand: "Gruppe erweitern",
+  gridGroupCollapse: "Gruppe reduzieren",
+  gridSummary: "Ergebnissummen",
+  gridGroupOrder: "Die Gruppenreihenfolge ist im Bericht festgelegt",
+  gridExportProgress: "{completed} von {total} Datensätzen",
+  gridExportReading: "{completed} Datensätze",
+  gridExportCancelled: "Export abgebrochen",
+  gridCancelExport: "Export abbrechen",
+  gridPrint: "Drucken",
+  gridCloseRecord: "Datensatzdetails schließen",
+  gridContains: "enthält",
+  gridStartsWith: "beginnt mit",
+  gridIn: "ist einer der Werte",
+  gridIsNull: "fehlt",
+  gridIsNotNull: "ist vorhanden",
+  visibleColumns: "Sichtbare Spalten",
+  resizeColumn: "Breite von {column} ändern",
+  columnWidth: "{width} Pixel",
+  loading: "Wird geladen…",
+  loadError: "Laden fehlgeschlagen: {error} (Eingabe zum Wiederholen)",
+  queryFailed: "Ansicht konnte nicht aktualisiert werden: {error}",
+  actions: "Aktionen",
+  editValue: "{column} bearbeiten",
+  saveEdit: "Speichern",
+  cancelEdit: "Abbrechen",
+  invalidEdit: "Einen gültigen Wert für {column} eingeben.",
+  interactionPending: "Warten auf die Anwendung…",
+  interactionRejected: "Die Anwendung hat den Vorgang abgelehnt.",
+  interactionFailed: "Vorgang fehlgeschlagen: {error}",
+  markMove: "Diesen Knoten verschieben",
+  moveHere: "Hierher verschieben",
+  moveBefore: "Davor verschieben",
+  moveAfter: "Danach verschieben",
+  cancelMove: "Verschieben abbrechen",
+  showMore: "Mehr anzeigen ({loaded} von {total} geladen)",
+  showMoreUnknownTotal: "Mehr anzeigen ({loaded} geladen)",
+  pageLoaded: "{loaded} von {total} geladen",
+  itemsLoaded: "{count} Elemente",
+  yes: "Ja",
+  no: "Nein",
+  utcTime: "{time} UTC",
+  localTime: "{time} Ortszeit",
+  mountError: "Diese Ansicht konnte nicht angezeigt werden: {error}",
+});
+const staticLabels = Object.freeze({
+  overflowNote: "{shown} Zeilen angezeigt. Gesamtzahl: {total}.",
+  unknownTotal: "unbekannt",
+  hiddenRows: "{count} weitere Zeilen werden nicht angezeigt",
+  fullReport: "Vollständigen Bericht öffnen",
+});
+export { labels, staticLabels };
+export default labels;

package/JavaScript/locales/es.d.ts

@@ -0,0 +1,6 @@
+import type { CanopyLabels } from "../protocol.js";
+/** Complete Spanish browser labels; individual properties can be overridden by the host. */
+export const labels: Readonly<Required<CanopyLabels>>;
+/** Labels used only by a script-free static fallback. */
+export const staticLabels: Readonly<{ overflowNote: string; unknownTotal: string; hiddenRows: string; fullReport: string }>;
+export default labels;

package/JavaScript/locales/es.mjs

@@ -0,0 +1,223 @@
+// Generated from CanopyX/Views/Locales/labels.json by Build/Sync-Assets.ps1.
+const labels = Object.freeze({
+  searchPlaceholder: "Buscar",
+  searchResults: "Resultados de búsqueda",
+  searchResultCount: "{count} resultados",
+  searchResultCountOfTotal: "{count} de {total} resultados",
+  searchResultCountOfMany: "{count} de muchos resultados",
+  searchNoResults: "Sin resultados",
+  searchTooShort: "Escriba al menos {min} caracteres",
+  searchWordTooShort: "Escriba una palabra de al menos {min} caracteres",
+  searchFailed: "Error al buscar: {error}",
+  columns: "Columnas",
+  gridFilters: "Filtros",
+  gridFitContent: "Ajustar al contenido",
+  gridUnpin: "Desfijar",
+  gridWhere: "Donde",
+  gridComplexFilter: "Esta columna pertenece a un grupo mixto de condiciones. Edítelo en Filtros.",
+  gridClearColumnFilter: "Borrar filtro",
+  gridSelectionAggregate: "Cantidad: {count} · Suma: {sum} · Media: {average} · Mínimo: {minimum} · Máximo: {maximum}",
+  gridConditionValue: "Valor",
+  gridConditionUpperValue: "Valor superior",
+  gridDeleteCondition: "Eliminar condición",
+  gridShowRowsWhere: "Mostrar filas donde",
+  gridOfTheseAreTrue: "de estas condiciones se cumplen",
+  gridOfThese: "de estas condiciones",
+  gridGroupCount: "{count} grupos",
+  gridMore: "Más",
+  gridDone: "Listo",
+  gridClearAll: "Borrar todo",
+  gridRows: "filas",
+  gridResultNoun: "{count} de {total} {noun}",
+  gridSearchNoun: "Buscar {noun}",
+  gridChart: "Gráfico",
+  gridColumnMenu: "Menú de {column}",
+  gridSortAscending: "Ordenar ascendente",
+  gridSortDescending: "Ordenar descendente",
+  gridClearSort: "Borrar orden",
+  gridFilterColumn: "Filtrar…",
+  gridHideColumn: "Ocultar columna",
+  gridGroupedBy: "Agrupado por",
+  gridRemoveGrouping: "Quitar agrupación",
+  gridSelectAllValues: "Seleccionar todos los valores",
+  gridFilterValues: "Buscar valores",
+  gridAddCondition: "+ Condición",
+  gridAddGroup: "+ Grupo",
+  gridAnd: "y",
+  gridOr: "o",
+  gridEditAsText: "Editar como texto",
+  gridFilterText: "Expresión de filtro",
+  gridDeepFilters: "Este filtro guardado tiene más de dos niveles de anidación.",
+  gridToday: "Hoy",
+  gridYesterday: "Ayer",
+  gridLastSevenDays: "Últimos 7 días",
+  gridLastThirtyDays: "Últimos 30 días",
+  gridThisMonth: "Este mes",
+  gridDateRange: "Rango",
+  gridEmpty: "Sin {noun}",
+  gridEmptyReason: "No hay registros que mostrar.",
+  gridNoMatches: "Sin {noun} coincidentes",
+  gridNoMatchesReason: "Búsqueda: {search}. Filtros activos: {count}.",
+  gridRetry: "Reintentar",
+  gridLoadFailed: "No se pudieron cargar los registros",
+  gridAll: "Todo",
+  gridPageOf: "{page} de {pages}",
+  gridStatusCount: "{count} {noun} · {selected} seleccionados",
+  gridDetailsSection: "Detalles",
+  gridPreviousRecord: "Registro anterior",
+  gridNextRecord: "Registro siguiente",
+  gridShowMore: "Mostrar más",
+  gridNoData: "Sin datos",
+  gridPeriodRange: "{from}–{to}: {state}",
+  gridHealthy: "Correcto",
+  gridResultCount: "{count} de {total} filas",
+  gridUnknownCount: "El número de resultados no está disponible",
+  gridMatchedCount: "{count} filas coincidentes",
+  gridCursorRange: "Filas {first}–{last}",
+  gridPaging: "Páginas de resultados",
+  gridPageRange: "Filas {first}–{last} de {count}",
+  gridPageNumber: "Página",
+  gridPageLength: "Filas por página",
+  gridFirstPage: "Primera página",
+  gridPreviousPage: "Página anterior",
+  gridNextPage: "Página siguiente",
+  gridLastPage: "Última página",
+  gridClearQuery: "Borrar búsqueda y filtros",
+  gridRemoveSearch: "Borrar búsqueda: {search}",
+  gridGroupedFilters: "Filtros agrupados ({count} condiciones)",
+  gridRemoveGroup: "Borrar filtros agrupados",
+  gridRemoveCondition: "Quitar condición: {condition}",
+  gridExport: "Exportar",
+  gridFilteredResults: "Resultados filtrados",
+  gridSelectedRows: "Filas seleccionadas",
+  gridAllResults: "Todos los resultados",
+  gridDownloadCsv: "Descargar CSV",
+  gridCopy: "Copiar",
+  gridDetails: "Detalles del registro",
+  gridColumn: "Columna",
+  gridOperator: "Condición",
+  gridValue: "Valor (fechas en UTC)",
+  gridValueType: "Tipo del valor original",
+  gridText: "Texto",
+  gridBoolean: "Valor lógico",
+  gridAddFilter: "Agregar filtro",
+  gridRemoveFilter: "Quitar filtro de {column}",
+  gridApply: "Aplicar",
+  gridClearFilters: "Borrar todos los filtros",
+  gridMoveEarlier: "Mover {column} a la izquierda",
+  gridMoveLater: "Mover {column} a la derecha",
+  gridViews: "Vistas",
+  gridViewName: "Nombre de la vista",
+  gridSaveView: "Guardar vista",
+  gridRemoveView: "Eliminar vista",
+  gridResetView: "Restablecer vista",
+  gridChooseView: "Seleccionar una vista guardada",
+  gridInvalidFilter: "Escriba un valor de filtro válido.",
+  gridBetween: "entre (inclusive)",
+  gridRangeEnd: "Valor superior (fechas en UTC)",
+  gridInvalidRange: "El valor superior debe ser mayor o igual que el inferior.",
+  gridSuggestedCategory: "Categoría sugerida",
+  gridChooseCategory: "Seleccionar categoría",
+  gridBooleanValue: "Valor lógico",
+  gridTrue: "Verdadero",
+  gridFalse: "Falso",
+  gridHeaderFilter: "Filtrar {column}",
+  gridExpandCell: "{column}: mostrar el texto completo",
+  gridCloseCell: "Cerrar el texto completo",
+  gridMoveColumn: "{column}: arrastre para mover o use las flechas izquierda y derecha",
+  gridResizeHelp: "Entrar ajusta el ancho a un máximo de 200 filas cargadas; las flechas izquierda y derecha cambian el ancho.",
+  gridFitColumn: "Ajustar {column}",
+  gridFitAllColumns: "Ajustar todas las columnas",
+  gridColumnMoved: "{column} se ha movido a la posición {position}",
+  gridPinColumn: "{column}: fijar columna",
+  gridPinNone: "Desplazable",
+  gridPinLeft: "Fijar a la izquierda",
+  gridPinRight: "Fijar a la derecha",
+  gridResponsiveHidden: "Oculta con este ancho",
+  gridFindColumn: "Buscar una columna…",
+  gridShowAllColumns: "Mostrar todas",
+  gridResetColumns: "Restablecer columnas",
+  gridReorderColumn: "{column}: arrastre o pulse Alt+Flecha arriba o Alt+Flecha abajo para mover",
+  gridPinnedLeft: "Fijada a la izquierda",
+  gridPinnedRight: "Fijada a la derecha",
+  gridFilterGroupTitle: "Grupos de condiciones adicionales",
+  gridFilterMatch: "Coincidencia",
+  gridFilterAll: "Todas",
+  gridFilterAny: "Cualquiera",
+  gridAddFilterGroup: "Agregar grupo de condiciones",
+  gridDeleteFilterGroup: "Quitar grupo de condiciones",
+  gridFacetValues: "Valores y recuentos con los filtros aplicados",
+  gridFacetSearch: "Buscar valores",
+  gridFacetIncludeCurrent: "Incluir los filtros aplicados a esta columna",
+  gridFacetLoad: "Cargar valores",
+  gridFacetChoose: "Seleccionar un valor",
+  gridFacetCounts: "{count} filas coincidentes; {shown} de {total} valores.",
+  gridFacetReload: "Los valores han cambiado o se ha cancelado la solicitud. Vuelva a cargar los valores.",
+  gridRenameView: "Cambiar nombre de la vista",
+  gridDefaultView: "Establecer como predeterminada",
+  gridClearDefaultView: "Quitar la vista predeterminada",
+  gridDefaultViewName: "Vista predeterminada: {name}",
+  gridNoDefaultView: "Sin vista predeterminada",
+  gridDefaultViewOption: "{name} (predeterminada)",
+  gridSelection: "Selección",
+  gridSelectPage: "Seleccionar página",
+  gridSelectMatching: "Seleccionar todos los coincidentes",
+  gridClearSelection: "Borrar selección",
+  gridSelectionCount: "{count} seleccionados",
+  gridSelectionQueryCount: "{count} registros coincidentes seleccionados; {excluded} excluidos",
+  gridSelectionQueryUnknown: "Todos los registros coincidentes seleccionados; {excluded} excluidos",
+  gridSelectRecord: "Seleccionar registro {id}",
+  gridGroupHeading: "{column}: {value} ({count} registros)",
+  gridGroupMissing: "Valor ausente",
+  gridGroupExpand: "Expandir grupo",
+  gridGroupCollapse: "Contraer grupo",
+  gridSummary: "Totales de resultados",
+  gridGroupOrder: "El orden de los grupos está fijado en este informe",
+  gridExportProgress: "{completed} de {total} registros",
+  gridExportReading: "{completed} registros",
+  gridExportCancelled: "Exportación cancelada",
+  gridCancelExport: "Cancelar exportación",
+  gridPrint: "Imprimir",
+  gridCloseRecord: "Cerrar detalles del registro",
+  gridContains: "contiene",
+  gridStartsWith: "empieza por",
+  gridIn: "es uno de estos valores",
+  gridIsNull: "está ausente",
+  gridIsNotNull: "está presente",
+  visibleColumns: "Columnas visibles",
+  resizeColumn: "Cambiar ancho de {column}",
+  columnWidth: "{width} píxeles",
+  loading: "Cargando…",
+  loadError: "No se pudo cargar: {error} (Entrar para reintentar)",
+  queryFailed: "No se pudo actualizar la vista: {error}",
+  actions: "Acciones",
+  editValue: "Editar {column}",
+  saveEdit: "Guardar",
+  cancelEdit: "Cancelar",
+  invalidEdit: "Escriba un valor válido para {column}.",
+  interactionPending: "Esperando a la aplicación…",
+  interactionRejected: "La aplicación ha rechazado la operación.",
+  interactionFailed: "Error en la operación: {error}",
+  markMove: "Mover este nodo",
+  moveHere: "Mover aquí",
+  moveBefore: "Mover antes",
+  moveAfter: "Mover después",
+  cancelMove: "Cancelar movimiento",
+  showMore: "Mostrar más ({loaded} de {total} cargados)",
+  showMoreUnknownTotal: "Mostrar más ({loaded} cargados)",
+  pageLoaded: "{loaded} de {total} cargados",
+  itemsLoaded: "{count} elementos",
+  yes: "Sí",
+  no: "No",
+  utcTime: "{time} UTC",
+  localTime: "{time} hora local",
+  mountError: "No se pudo mostrar esta vista: {error}",
+});
+const staticLabels = Object.freeze({
+  overflowNote: "Filas mostradas: {shown}. Total: {total}.",
+  unknownTotal: "desconocido",
+  hiddenRows: "No se muestran {count} filas más",
+  fullReport: "Abrir el informe completo",
+});
+export { labels, staticLabels };
+export default labels;

package/JavaScript/locales/pl.d.ts

@@ -0,0 +1,6 @@
+import type { CanopyLabels } from "../protocol.js";
+/** Complete Polish browser labels; individual properties can be overridden by the host. */
+export const labels: Readonly<Required<CanopyLabels>>;
+/** Labels used only by a script-free static fallback. */
+export const staticLabels: Readonly<{ overflowNote: string; unknownTotal: string; hiddenRows: string; fullReport: string }>;
+export default labels;