@vobs/table 1.0.0 → 1.2.0

package/dist/types.d.ts

@@ -0,0 +1,164 @@
+import { Signal } from '@vobs/reactivity';
+import { VobsNode } from '@vobs/vobs';
+
+type DataTableAlign = 'start' | 'center' | 'end';
+type DataTableSortDirection = 'asc' | 'desc';
+type DataTableSortType = 'text' | 'number' | 'date' | 'boolean';
+type DataTableSortingMode = 'client' | 'server';
+type DataTablePaginationMode = 'simple' | 'standard' | 'all';
+interface DataTableSort {
+    readonly columnId: string;
+    readonly direction: DataTableSortDirection;
+    /** Optional backend field supplied by the column definition. */
+    readonly sortKey?: string;
+}
+interface DataTableQuery {
+    readonly page: number;
+    readonly pageSize: number;
+    readonly sort: DataTableSort | null;
+    readonly filters: Readonly<Record<string, unknown>>;
+}
+interface DataTablePage<Row> {
+    readonly rows: readonly Row[];
+    readonly total?: number;
+}
+type DataTableResourceData<Row> = readonly Row[] | DataTablePage<Row>;
+interface DataTableResource<Row> {
+    readonly data: {
+        readonly value: DataTableResourceData<Row> | null;
+    };
+    readonly error: {
+        readonly value: Error | null;
+    };
+    readonly loading: {
+        readonly value: boolean;
+    };
+    refetch(): Promise<unknown>;
+}
+type DataTableChildren = VobsNode | string | number | readonly DataTableChildren[] | (() => DataTableChildren | null | undefined);
+interface DataTableColumn<Row = Record<string, unknown>> {
+    readonly id: string;
+    readonly label: string;
+    readonly key?: keyof Row;
+    readonly render?: (row: Row, index: number) => DataTableChildren;
+    readonly compare?: (left: Row, right: Row) => number;
+    /** Value used by the built-in client sorter when compare is not provided. */
+    readonly sortValue?: (row: Row) => unknown;
+    /** Optional value kind for deterministic client-side sorting. */
+    readonly sortType?: DataTableSortType;
+    /** Backend field mapping; emitted together with the stable column id in DataTableSort. */
+    readonly sortKey?: string;
+    /** Apply a filter value supplied by the page or another external filter control. */
+    readonly filter?: (row: Row, value: unknown) => boolean;
+    readonly sortable?: boolean;
+    /** Marks a column as supported by an external filter UI; no control is rendered in the table. */
+    readonly filterable?: boolean;
+    readonly visible?: boolean;
+    readonly align?: DataTableAlign;
+    readonly width?: string | number;
+    readonly minWidth?: string | number;
+}
+interface DataTableColumnSettings {
+    readonly visibleColumnIds: readonly string[];
+    readonly columnOrder: readonly string[];
+    readonly columnWidths: Readonly<Record<string, string | number>>;
+}
+interface DataTableColumnSettingsPersistence {
+    load(): DataTableColumnSettings | null | undefined;
+    save(settings: DataTableColumnSettings): void;
+    reset?(): void;
+}
+/** Minimal storage shape accepted by createColumnSettingsPersistence. */
+interface DataTableColumnSettingsStorage {
+    get<T>(key: string): T | null | undefined;
+    set<T>(key: string, value: T): void;
+    remove(key: string): void;
+}
+interface DataTableIcons {
+    readonly ascending?: DataTableChildren;
+    readonly descending?: DataTableChildren;
+    readonly unsorted?: DataTableChildren;
+    readonly previous?: DataTableChildren;
+    readonly next?: DataTableChildren;
+}
+interface DataTablePaginationContext {
+    readonly page: number;
+    readonly pageCount: number;
+    readonly pageSize: number;
+    readonly pageSizeOptions: readonly number[];
+    readonly total: number;
+    readonly visibleCount: number;
+    readonly goToPage: (page: number) => void;
+    readonly setPageSize: (pageSize: number) => void;
+}
+type DataTablePagination = DataTableChildren | ((context: DataTablePaginationContext) => DataTableChildren | null | undefined);
+interface DataTableCommonProps {
+    readonly class?: string;
+    readonly className?: string;
+    readonly style?: string;
+    readonly id?: string;
+    readonly title?: string;
+    readonly role?: string;
+    readonly tabIndex?: number;
+    readonly [name: `aria-${string}`]: string | number | boolean | undefined;
+    readonly [name: `data-${string}`]: string | number | boolean | undefined;
+}
+interface KitDataTableProps<Row = Record<string, unknown>> extends DataTableCommonProps {
+    readonly columns?: readonly DataTableColumn<Row>[];
+    readonly rows?: readonly Row[];
+    readonly resource?: DataTableResource<Row>;
+    readonly rowKey?: (row: Row, index: number) => unknown;
+    /** 传入 Signal 时受控分页：表格翻页后自动写回信号。 */
+    readonly page?: number | Signal<number>;
+    readonly pageSize?: number | Signal<number>;
+    readonly total?: number;
+    readonly sort?: DataTableSort | null;
+    /** Client sorts loaded rows; server leaves row order to the resource owner. */
+    readonly sortingMode?: DataTableSortingMode;
+    /** Query state is owned by the caller when provided and is never edited by table-owned inputs. */
+    readonly filters?: Readonly<Record<string, unknown>>;
+    readonly columnSettings?: DataTableColumnSettings;
+    readonly visibleColumnIds?: readonly string[];
+    readonly virtual?: boolean;
+    readonly stickyHeader?: boolean;
+    readonly virtualHeight?: number;
+    readonly rowHeight?: number;
+    readonly overscan?: number;
+    readonly loading?: DataTableChildren;
+    readonly empty?: DataTableChildren;
+    readonly error?: (error: Error, retry: () => Promise<unknown>) => DataTableChildren;
+    readonly toolbar?: DataTableChildren;
+    readonly footer?: DataTableChildren;
+    readonly pagination?: DataTablePagination;
+    readonly paginationMode?: DataTablePaginationMode;
+    readonly pageSizeOptions?: readonly number[];
+    readonly pageSizeLabel?: string;
+    readonly icons?: DataTableIcons;
+    readonly previousLabel?: string;
+    readonly nextLabel?: string;
+    readonly jumpToLabel?: string;
+    readonly jumpToPlaceholder?: string;
+    readonly jumpToSubmitLabel?: string;
+    /** Formats the footer summary. The last two arguments are visible row count and page size. */
+    readonly pageLabel?: (page: number, pageCount: number, total: number, visibleCount: number, pageSize: number) => string;
+    /** Receives table-originated sort and pagination changes for a page-level query controller. */
+    readonly onQueryChange?: (query: DataTableQuery) => void;
+    readonly onRowClick?: (row: Row, index: number) => void;
+    readonly onVisibleColumnIdsChange?: (ids: readonly string[]) => void;
+}
+interface KitColumnSettingsProps<Row = Record<string, unknown>> extends DataTableCommonProps {
+    readonly columns?: readonly DataTableColumn<Row>[];
+    readonly settings?: DataTableColumnSettings;
+    readonly persistence?: DataTableColumnSettingsPersistence;
+    readonly visibleColumnIds?: readonly string[];
+    readonly trigger?: DataTableChildren;
+    readonly label?: string;
+    readonly closeLabel?: string;
+    readonly resetLabel?: string;
+    readonly onChange?: (ids: readonly string[]) => void;
+    readonly onSettingsChange?: (settings: DataTableColumnSettings) => void;
+    readonly onReset?: () => void;
+    readonly onPersistenceError?: (error: unknown) => void;
+}
+
+export type { DataTableAlign, DataTableChildren, DataTableColumn, DataTableColumnSettings, DataTableColumnSettingsPersistence, DataTableColumnSettingsStorage, DataTableCommonProps, DataTableIcons, DataTablePage, DataTablePagination, DataTablePaginationContext, DataTablePaginationMode, DataTableQuery, DataTableResource, DataTableResourceData, DataTableSort, DataTableSortDirection, DataTableSortType, DataTableSortingMode, KitColumnSettingsProps, KitDataTableProps };

package/dist/types.js

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=types.js.map
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"types.js"}

package/dist/utils.cjs

@@ -0,0 +1,525 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// packages/reactivity/src/debug.ts
+var activeDebugHooks = null;
+function hasDebugHooks() {
+  return activeDebugHooks !== null;
+}
+__name(hasDebugHooks, "hasDebugHooks");
+function invokeDebug(name, ...args) {
+  return;
+}
+__name(invokeDebug, "invokeDebug");
+
+// packages/reactivity/src/owner.ts
+var currentOwner = null;
+function getCurrentOwner() {
+  return currentOwner;
+}
+__name(getCurrentOwner, "getCurrentOwner");
+
+// packages/reactivity/src/signal.ts
+var currentSubscriber = null;
+function getCurrentSubscriber() {
+  return currentSubscriber;
+}
+__name(getCurrentSubscriber, "getCurrentSubscriber");
+function setCurrentSubscriber(subscriber) {
+  currentSubscriber = subscriber;
+}
+__name(setCurrentSubscriber, "setCurrentSubscriber");
+
+// packages/reactivity/src/scheduler.ts
+var _Scheduler = class _Scheduler {
+  constructor() {
+    this.dirtyEffects = /* @__PURE__ */ new Set();
+    this.lowPriorityEffects = /* @__PURE__ */ new Set();
+    // flush 不可重入（flushing 标志保证），缓冲数组可在轮次间安全复用，避免每轮分配。
+    this.normalBuffer = [];
+    this.lowBuffer = [];
+    this.flushing = false;
+    this.scheduled = false;
+    this.batchDepth = 0;
+  }
+  schedule(effect2) {
+    if (effect2.disposed) return;
+    this.dirtyEffects.add(effect2);
+    this.lowPriorityEffects.delete(effect2);
+    this.ensureScheduled();
+  }
+  /** Queue an effect behind normal updates while preserving deterministic order. */
+  scheduleLow(effect2) {
+    if (effect2.disposed) return;
+    if (!this.dirtyEffects.has(effect2)) this.lowPriorityEffects.add(effect2);
+    this.ensureScheduled();
+  }
+  ensureScheduled() {
+    if (this.batchDepth === 0 && !this.flushing && !this.scheduled) {
+      this.scheduled = true;
+      queueMicrotask(() => {
+        this.scheduled = false;
+        this.flush();
+      });
+    }
+  }
+  remove(effect2) {
+    this.dirtyEffects.delete(effect2);
+    this.lowPriorityEffects.delete(effect2);
+  }
+  batch(fn) {
+    this.batchDepth++;
+    try {
+      return fn();
+    } finally {
+      this.batchDepth--;
+      if (this.batchDepth === 0) this.flush();
+    }
+  }
+  flush() {
+    if (this.flushing || this.batchDepth > 0) return;
+    this.flushing = true;
+    let rounds = 0;
+    let firstError;
+    let hasError = false;
+    try {
+      while (this.dirtyEffects.size > 0 || this.lowPriorityEffects.size > 0) {
+        if (++rounds > 100) {
+          this.dirtyEffects.clear();
+          this.lowPriorityEffects.clear();
+          throw new Error("Vobs: \u54CD\u5E94\u5F0F\u66F4\u65B0\u8D85\u8FC7 100 \u8F6E\uFF0C\u53EF\u80FD\u5B58\u5728\u5FAA\u73AF\u4F9D\u8D56");
+        }
+        this.collectRunnable(this.dirtyEffects, this.normalBuffer);
+        this.collectRunnable(this.lowPriorityEffects, this.lowBuffer);
+        sortEffects(this.normalBuffer);
+        sortEffects(this.lowBuffer);
+        for (const effect2 of this.normalBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        for (const effect2 of this.lowBuffer) {
+          try {
+            effect2.run();
+          } catch (error) {
+            if (!hasError) {
+              firstError = error;
+              hasError = true;
+            }
+          }
+        }
+        this.normalBuffer.length = 0;
+        this.lowBuffer.length = 0;
+      }
+    } finally {
+      this.normalBuffer.length = 0;
+      this.lowBuffer.length = 0;
+      this.flushing = false;
+    }
+    if (hasError) throw firstError;
+  }
+  /** 收集未 disposed 的 effect 并清空源集合；run() 期间新调度的 effect 留给下一轮。 */
+  collectRunnable(source, target) {
+    for (const effect2 of source) {
+      if (!effect2.disposed) target.push(effect2);
+    }
+    source.clear();
+  }
+};
+__name(_Scheduler, "Scheduler");
+var Scheduler = _Scheduler;
+function sortEffects(effects) {
+  if (effects.length > 1) {
+    effects.sort((a, b) => b.depth - a.depth || a.order - b.order);
+  }
+}
+__name(sortEffects, "sortEffects");
+var scheduler = new Scheduler();
+
+// packages/reactivity/src/effect.ts
+var nextEffectOrder = 1;
+function cleanupDependencies(subscriber) {
+  for (const dependency of subscriber.dependencies) {
+    dependency.unsubscribe(subscriber);
+  }
+  subscriber.dependencies.clear();
+}
+__name(cleanupDependencies, "cleanupDependencies");
+function effect(callback) {
+  const owner = getCurrentOwner();
+  let cleanup;
+  let dirty = true;
+  let disposed = false;
+  const eff = {
+    order: nextEffectOrder++,
+    depth: owner?.depth ?? 0,
+    dependencies: /* @__PURE__ */ new Set(),
+    get disposed() {
+      return disposed;
+    },
+    notify() {
+      if (disposed || dirty) return;
+      dirty = true;
+      scheduler.schedule(eff);
+    },
+    run() {
+      if (disposed || !dirty) return;
+      dirty = false;
+      const previousCleanup = cleanup;
+      cleanup = void 0;
+      let cleanupError;
+      if (previousCleanup) {
+        try {
+          previousCleanup();
+        } catch (error) {
+          cleanupError = error;
+        }
+      }
+      cleanupDependencies(eff);
+      const previous = getCurrentSubscriber();
+      setCurrentSubscriber(eff);
+      let thrown;
+      let handled = false;
+      try {
+        const result = owner ? owner.run(callback) : callback();
+        cleanup = typeof result === "function" ? result : void 0;
+      } catch (error) {
+        thrown = error;
+        handled = false;
+        if (!handled) throw error;
+      } finally {
+        setCurrentSubscriber(previous);
+      }
+      if (cleanupError && !thrown) throw cleanupError;
+    },
+    scheduleLow() {
+      if (disposed || dirty) return;
+      dirty = true;
+      scheduler.scheduleLow(eff);
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      dirty = false;
+      scheduler.remove(eff);
+      const previousCleanup = cleanup;
+      cleanup = void 0;
+      let cleanupError;
+      if (previousCleanup) {
+        try {
+          previousCleanup();
+        } catch (error) {
+          cleanupError = error;
+        }
+      }
+      cleanupDependencies(eff);
+      if (cleanupError) throw cleanupError;
+    }
+  };
+  eff.run();
+  return eff;
+}
+__name(effect, "effect");
+
+// packages/runtime/src/debug.ts
+var activeRuntimeDebugHooks = null;
+function getRuntimeDebugHooks() {
+  return activeRuntimeDebugHooks;
+}
+__name(getRuntimeDebugHooks, "getRuntimeDebugHooks");
+function invokeRuntimeDebug(name, ...args) {
+  return;
+}
+__name(invokeRuntimeDebug, "invokeRuntimeDebug");
+function readDebugValue(read) {
+  try {
+    return read();
+  } catch {
+    return "[Uninspectable]";
+  }
+}
+__name(readDebugValue, "readDebugValue");
+function describeDebugNode(node) {
+  if (!node || typeof node !== "object") return "node";
+  const value = node;
+  const name = typeof value.tagName === "string" ? value.tagName.toLowerCase() : typeof value.nodeName === "string" ? value.nodeName.toLowerCase() : "node";
+  const id = typeof value.id === "string" && value.id ? `#${value.id}` : "";
+  const className = typeof value.className === "string" && value.className ? `.${value.className.trim().split(/\s+/).filter(Boolean).join(".")}` : "";
+  return `${name}${id}${className}`;
+}
+__name(describeDebugNode, "describeDebugNode");
+
+// packages/runtime/src/hmr.ts
+var globalTarget = globalThis;
+var hmrGlobal = globalTarget.__VOBS_HMR__ ?? { modules: /* @__PURE__ */ new Map() };
+globalTarget.__VOBS_HMR__ = hmrGlobal;
+function markHmrInstanceMounted(node, parent) {
+  const instance = hmrInstances.get(node);
+  if (instance) instance.parent = parent;
+}
+__name(markHmrInstanceMounted, "markHmrInstanceMounted");
+var hmrInstances = /* @__PURE__ */ new WeakMap();
+function getRenderer() {
+  {
+    throw new Error("\u6E32\u67D3\u5668\u672A\u521D\u59CB\u5316");
+  }
+}
+__name(getRenderer, "getRenderer");
+function createText(content) {
+  return getRenderer().createText(content);
+}
+__name(createText, "createText");
+function createComment(content) {
+  return getRenderer().createComment(content);
+}
+__name(createComment, "createComment");
+function insertBefore(parent, child, anchor) {
+  if (isVobsFragment(child)) {
+    child.mount(parent, isVobsFragment(anchor) ? anchor.start : anchor);
+    return;
+  }
+  getRenderer().insertBefore(parent, child, isVobsFragment(anchor) ? anchor.start : anchor);
+  markHmrInstanceMounted(child, parent);
+}
+__name(insertBefore, "insertBefore");
+function setTextContent(node, content) {
+  getRenderer().setTextContent(node, content);
+}
+__name(setTextContent, "setTextContent");
+function setAttribute(node, key, value) {
+  getRenderer().setAttribute(node, key, value);
+}
+__name(setAttribute, "setAttribute");
+
+// packages/runtime/src/fragment.ts
+function createFragment(factory) {
+  const start = createComment("vobs:fragment:start");
+  const end = createComment("vobs:fragment:end");
+  let parent = null;
+  let initialized = false;
+  const fragment = {
+    kind: "vobs-fragment",
+    start,
+    end,
+    mount(nextParent, anchor) {
+      if (parent && parent !== nextParent) {
+        throw new Error("Vobs Fragment: \u4E0D\u80FD\u8DE8\u7236\u8282\u70B9\u79FB\u52A8 Fragment");
+      }
+      if (initialized) {
+        moveRange(nextParent, start, end, anchor);
+        return;
+      }
+      const renderer = getRenderer();
+      renderer.insertBefore(nextParent, start, anchor);
+      renderer.insertBefore(nextParent, end, anchor);
+      parent = nextParent;
+      initialized = true;
+      factory(nextParent, end);
+    },
+    unmount(nextParent) {
+      if (!initialized || parent !== nextParent) {
+        throw new Error("Vobs Fragment: Fragment \u4E0D\u5C5E\u4E8E\u6307\u5B9A\u7236\u8282\u70B9");
+      }
+      const renderer = getRenderer();
+      let current = renderer.nextSibling(start);
+      while (current && current !== end) {
+        const next = renderer.nextSibling(current);
+        renderer.removeChild(nextParent, current);
+        current = next;
+      }
+      renderer.removeChild(nextParent, start);
+      renderer.removeChild(nextParent, end);
+      parent = null;
+      initialized = false;
+    }
+  };
+  return fragment;
+}
+__name(createFragment, "createFragment");
+function isVobsFragment(value) {
+  return Boolean(value) && typeof value === "object" && value.kind === "vobs-fragment";
+}
+__name(isVobsFragment, "isVobsFragment");
+function moveRange(parent, start, end, anchor) {
+  const renderer = getRenderer();
+  const nodes = [start];
+  let current = renderer.nextSibling(start);
+  while (current) {
+    nodes.push(current);
+    if (current === end) break;
+    current = renderer.nextSibling(current);
+  }
+  if (nodes[nodes.length - 1] !== end) {
+    throw new Error("Vobs Fragment: \u627E\u4E0D\u5230\u7ED3\u675F\u951A\u70B9");
+  }
+  for (const node of nodes) renderer.insertBefore(parent, node, anchor);
+}
+__name(moveRange, "moveRange");
+
+// packages/table/src/utils.ts
+function readProp(props, name, fallback) {
+  const value = Reflect.get(props, name);
+  return value === void 0 ? fallback : value;
+}
+__name(readProp, "readProp");
+function hasProp(props, name) {
+  return name in props;
+}
+__name(hasProp, "hasProp");
+function bindClassList(root, props, classes) {
+  effect(() => {
+    const userClasses = [readString(props, "class"), readString(props, "className")];
+    setAttribute(root, "class", [...classes(), ...userClasses].filter(Boolean).join(" "));
+  });
+}
+__name(bindClassList, "bindClassList");
+function bindCommonAttributes(root, props, skip) {
+  const ignored = /* @__PURE__ */ new Set([...skip, "class", "className", "style", "children"]);
+  effect(() => {
+    for (const name of Object.keys(props)) {
+      if (ignored.has(name) || name.startsWith("on")) continue;
+      if (name !== "id" && name !== "title" && name !== "role" && name !== "tabIndex" && !name.startsWith("aria-") && !name.startsWith("data-")) continue;
+      const value = Reflect.get(props, name);
+      if (value === void 0 || value === null || value === false) removeAttribute(root, normalizeAttributeName(name));
+      else setAttribute(root, normalizeAttributeName(name), String(value));
+    }
+  });
+}
+__name(bindCommonAttributes, "bindCommonAttributes");
+function bindStyle(root, props, internal = () => "") {
+  effect(() => {
+    const value = [internal(), readString(props, "style")].filter(Boolean).join("; ");
+    if (value) setAttribute(root, "style", value);
+    else removeAttribute(root, "style");
+  });
+}
+__name(bindStyle, "bindStyle");
+function bindText2(node, read) {
+  effect(() => setTextContent(node, String(read() ?? "")));
+}
+__name(bindText2, "bindText");
+function resolveSlot(value) {
+  const resolved = typeof value === "function" ? value() : value;
+  if (resolved === void 0 || resolved === null) return null;
+  if (typeof resolved === "string" || typeof resolved === "number") return createText(String(resolved));
+  if (Array.isArray(resolved)) {
+    return createFragment((parent, anchor) => {
+      for (const child of resolved) {
+        const node = resolveSlot(child);
+        if (node) insertBefore(parent, node, anchor);
+      }
+    });
+  }
+  return resolved;
+}
+__name(resolveSlot, "resolveSlot");
+function setOptionalAttribute(node, name, value) {
+  if (value === void 0 || value === null || value === false || value === "") removeAttribute(node, name);
+  else setAttribute(node, name, String(value));
+}
+__name(setOptionalAttribute, "setOptionalAttribute");
+function normalizePixels(value) {
+  if (value === void 0) return void 0;
+  return typeof value === "number" ? `${value}px` : value;
+}
+__name(normalizePixels, "normalizePixels");
+function createDefaultColumnSettings(columns, visibleColumnIds) {
+  const columnOrder = columns.map((column) => column.id);
+  const requested = new Set(visibleColumnIds ?? columns.filter((column) => column.visible !== false).map((column) => column.id));
+  const visible = columnOrder.filter((id) => requested.has(id) && columns.some((column) => column.id === id && column.visible !== false));
+  if (visible.length === 0) {
+    const fallback = columns.find((column) => column.visible !== false);
+    if (fallback) visible.push(fallback.id);
+  }
+  return { visibleColumnIds: visible, columnOrder, columnWidths: {} };
+}
+__name(createDefaultColumnSettings, "createDefaultColumnSettings");
+function normalizeColumnSettings(columns, settings, visibleColumnIds) {
+  const fallback = createDefaultColumnSettings(columns, visibleColumnIds);
+  const knownIds = new Set(fallback.columnOrder);
+  const configuredOrder = Array.isArray(settings?.columnOrder) ? settings.columnOrder : void 0;
+  const order = uniqueKnownIds(configuredOrder, knownIds);
+  for (const id of fallback.columnOrder) {
+    if (!order.includes(id)) order.push(id);
+  }
+  const configuredVisible = Array.isArray(settings?.visibleColumnIds) ? settings.visibleColumnIds : void 0;
+  const requestedVisible = new Set(configuredVisible ?? fallback.visibleColumnIds);
+  const visible = order.filter((id) => requestedVisible.has(id) && columns.some((column) => column.id === id && column.visible !== false));
+  if (visible.length === 0) {
+    const fallbackVisible = order.find((id) => columns.some((column) => column.id === id && column.visible !== false));
+    if (fallbackVisible) visible.push(fallbackVisible);
+  }
+  const columnWidths = {};
+  const configuredWidths = settings?.columnWidths && typeof settings.columnWidths === "object" && !Array.isArray(settings.columnWidths) ? settings.columnWidths : {};
+  for (const [id, width] of Object.entries(configuredWidths)) {
+    if (knownIds.has(id) && isColumnWidthValue(width)) columnWidths[id] = width;
+  }
+  return { visibleColumnIds: visible, columnOrder: order, columnWidths };
+}
+__name(normalizeColumnSettings, "normalizeColumnSettings");
+function orderColumns(columns, columnOrder) {
+  if (!columnOrder || columnOrder.length === 0) return columns;
+  const byId = new Map(columns.map((column) => [column.id, column]));
+  const ordered = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const id of columnOrder) {
+    const column = byId.get(id);
+    if (column && !seen.has(id)) {
+      ordered.push(column);
+      seen.add(id);
+    }
+  }
+  for (const column of columns) {
+    if (!seen.has(column.id)) ordered.push(column);
+  }
+  return ordered;
+}
+__name(orderColumns, "orderColumns");
+function isColumnWidthValue(value) {
+  return typeof value === "number" ? Number.isFinite(value) && value > 0 : typeof value === "string" && value.trim().length > 0 && !/[;{}]/u.test(value);
+}
+__name(isColumnWidthValue, "isColumnWidthValue");
+function uniqueKnownIds(values, knownIds) {
+  const result = [];
+  for (const id of values ?? []) {
+    if (knownIds.has(id) && !result.includes(id)) result.push(id);
+  }
+  return result;
+}
+__name(uniqueKnownIds, "uniqueKnownIds");
+function readString(props, name) {
+  const value = Reflect.get(props, name);
+  return typeof value === "string" ? value : void 0;
+}
+__name(readString, "readString");
+function normalizeAttributeName(name) {
+  return name === "tabIndex" ? "tabindex" : name;
+}
+__name(normalizeAttributeName, "normalizeAttributeName");
+function removeAttribute(node, name) {
+  node.removeAttribute(name);
+}
+__name(removeAttribute, "removeAttribute");
+
+exports.bindClassList = bindClassList;
+exports.bindCommonAttributes = bindCommonAttributes;
+exports.bindStyle = bindStyle;
+exports.bindText = bindText2;
+exports.createDefaultColumnSettings = createDefaultColumnSettings;
+exports.hasProp = hasProp;
+exports.isColumnWidthValue = isColumnWidthValue;
+exports.normalizeColumnSettings = normalizeColumnSettings;
+exports.normalizePixels = normalizePixels;
+exports.orderColumns = orderColumns;
+exports.readProp = readProp;
+exports.resolveSlot = resolveSlot;
+exports.setOptionalAttribute = setOptionalAttribute;
+//# sourceMappingURL=utils.cjs.map
+//# sourceMappingURL=utils.cjs.map