@vobs/table 1.0.0 → 1.2.0

package/dist/column-settings.js

@@ -0,0 +1,1034 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// packages/reactivity/src/debug.ts
+var activeDebugHooks = null;
+var signalNames = /* @__PURE__ */ new WeakMap();
+function hasDebugHooks() {
+  return activeDebugHooks !== null;
+}
+__name(hasDebugHooks, "hasDebugHooks");
+function setSignalDebugName(signal, name) {
+  signalNames.set(signal, name);
+  invokeDebug("signalNamed", signal, name);
+}
+__name(setSignalDebugName, "setSignalDebugName");
+function invokeDebug(name, ...args) {
+  return;
+}
+__name(invokeDebug, "invokeDebug");
+
+// packages/reactivity/src/owner.ts
+var currentOwner = null;
+var nextOwnerId = 1;
+var ownerNames = /* @__PURE__ */ new WeakMap();
+function createOwner() {
+  const parent = currentOwner;
+  let disposed = parent?.disposed ?? false;
+  const children = [];
+  const cleanups = [];
+  const errorHandlers = /* @__PURE__ */ new Set();
+  const owner = {
+    id: `owner-${nextOwnerId++}`,
+    parent,
+    children,
+    depth: (parent?.depth ?? -1) + 1,
+    get disposed() {
+      return disposed;
+    },
+    run(fn) {
+      if (disposed) throw new Error("Vobs: \u5DF2\u9500\u6BC1\u7684 Owner \u4E0D\u80FD\u7EE7\u7EED\u8FD0\u884C");
+      const previous = currentOwner;
+      currentOwner = owner;
+      try {
+        return fn();
+      } finally {
+        currentOwner = previous;
+      }
+    },
+    addCleanup(cleanup) {
+      if (disposed) {
+        cleanup();
+        return;
+      }
+      cleanups.push(cleanup);
+    },
+    onDispose(cleanup) {
+      owner.addCleanup(cleanup);
+    },
+    onError(handler) {
+      errorHandlers.add(handler);
+      const remove = /* @__PURE__ */ __name(() => errorHandlers.delete(handler), "remove");
+      owner.addCleanup(remove);
+      return remove;
+    },
+    handleError(error) {
+      for (const handler of [...errorHandlers].reverse()) {
+        try {
+          handler(error);
+          return true;
+        } catch (handlerError) {
+          return parent?.handleError(handlerError) ?? false;
+        }
+      }
+      return parent?.handleError(error) ?? false;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      for (const child of [...children]) child.dispose();
+      children.length = 0;
+      let firstError;
+      for (let index = cleanups.length - 1; index >= 0; index--) {
+        try {
+          cleanups[index]();
+        } catch (error) {
+          firstError ?? (firstError = error);
+        }
+      }
+      cleanups.length = 0;
+      if (parent) {
+        const index = parent.children.indexOf(owner);
+        if (index >= 0) parent.children.splice(index, 1);
+      }
+      if (firstError) throw firstError;
+    }
+  };
+  if (parent && !parent.disposed) parent.children.push(owner);
+  return owner;
+}
+__name(createOwner, "createOwner");
+function setOwnerDebugName(owner, name) {
+  ownerNames.set(owner, name);
+}
+__name(setOwnerDebugName, "setOwnerDebugName");
+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");
+function untrack(fn) {
+  const previous = currentSubscriber;
+  currentSubscriber = null;
+  try {
+    return fn();
+  } finally {
+    currentSubscriber = previous;
+  }
+}
+__name(untrack, "untrack");
+function trackDependency(dependency) {
+  if (!currentSubscriber || currentSubscriber.disposed) return;
+  !currentSubscriber.dependencies.has(dependency);
+  currentSubscriber.dependencies.add(dependency);
+}
+__name(trackDependency, "trackDependency");
+function state(initialValue, debugName) {
+  let value = initialValue;
+  let disposed = false;
+  const subscribers = /* @__PURE__ */ new Set();
+  const signalInstance = {
+    get value() {
+      const subscriber = getCurrentSubscriber();
+      if (subscriber && !subscriber.disposed) {
+        subscribers.add(subscriber);
+        trackDependency(signalInstance);
+      }
+      return value;
+    },
+    set value(nextValue) {
+      if (disposed || Object.is(value, nextValue)) return;
+      value = nextValue;
+      for (const subscriber of [...subscribers]) subscriber.notify();
+    },
+    unsubscribe(subscriber) {
+      subscribers.delete(subscriber);
+    },
+    // 与 `.value =` 赋值同一条路径：判等短路、debug hook、notify 全部一致。
+    // 以闭包实现，可安全地作为回调直接传递（无 this 绑定问题）。
+    set(next) {
+      signalInstance.value = next;
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      subscribers.clear();
+    }
+  };
+  const owner = getCurrentOwner();
+  owner?.addCleanup(signalInstance.dispose);
+  if (debugName?.trim()) setSignalDebugName(signalInstance, debugName.trim());
+  return signalInstance;
+}
+__name(state, "state");
+
+// 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) {
+          const handled2 = owner?.handleError(error) ?? false;
+          if (!handled2) 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 = owner?.handleError(error) ?? 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) {
+          const handled = owner?.handleError(error) ?? false;
+          if (!handled) cleanupError = error;
+        }
+      }
+      cleanupDependencies(eff);
+      if (cleanupError) throw cleanupError;
+    }
+  };
+  owner?.addCleanup(eff.dispose);
+  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();
+var nodeOwners = /* @__PURE__ */ new WeakMap();
+var eventBindings = /* @__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 createElement(tag) {
+  return getRenderer().createElement(tag);
+}
+__name(createElement, "createElement");
+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 removeChild(parent, child) {
+  disposeNodeOwner(child);
+  if (isVobsFragment(child)) {
+    child.unmount(parent);
+    return;
+  }
+  getRenderer().removeChild(parent, child);
+}
+__name(removeChild, "removeChild");
+function setTextContent(node, content) {
+  getRenderer().setTextContent(node, content);
+}
+__name(setTextContent, "setTextContent");
+function setProperty(node, key, value) {
+  getRenderer().setProperty(node, key, value);
+}
+__name(setProperty, "setProperty");
+function setAttribute(node, key, value) {
+  getRenderer().setAttribute(node, key, value);
+}
+__name(setAttribute, "setAttribute");
+function addEventListener(node, event, handler) {
+  const renderer = getRenderer();
+  const owner = getCurrentOwner();
+  let bindings = eventBindings.get(node);
+  if (!bindings) {
+    bindings = /* @__PURE__ */ new Map();
+    eventBindings.set(node, bindings);
+  }
+  const previous = bindings.get(event);
+  if (previous && previous.original === handler && previous.owner === owner) return;
+  if (previous) renderer.removeEventListener(node, event, previous.handler);
+  const listener = owner ? (reason) => {
+    try {
+      owner.run(() => handler(reason));
+    } catch (error) {
+      const handled = owner.handleError(error);
+      invokeRuntimeDebug("error", {
+        error,
+        owner,
+        phase: "event",
+        handled,
+        recovery: handled ? "handled" : "propagated"
+      });
+      if (!handled) throw error;
+    }
+  } : handler;
+  const binding = { handler: listener, owner, original: handler };
+  bindings.set(event, binding);
+  renderer.addEventListener(node, event, listener);
+  owner?.onDispose(() => {
+    if (bindings?.get(event) !== binding) return;
+    bindings.delete(event);
+    renderer.removeEventListener(node, event, listener);
+  });
+}
+__name(addEventListener, "addEventListener");
+function createBlock(factory) {
+  const owner = createOwner();
+  setOwnerDebugName(owner, "dynamic");
+  let node;
+  try {
+    node = owner.run(factory);
+  } catch (error) {
+    owner.dispose();
+    throw error;
+  }
+  if (!node) {
+    owner.dispose();
+    return null;
+  }
+  associateNodeOwner(node, owner);
+  return node;
+}
+__name(createBlock, "createBlock");
+function associateNodeOwner(node, owner) {
+  nodeOwners.set(node, owner);
+}
+__name(associateNodeOwner, "associateNodeOwner");
+function disposeNodeOwner(node) {
+  const owner = nodeOwners.get(node);
+  if (!owner) return;
+  nodeOwners.delete(node);
+  owner.dispose();
+}
+__name(disposeNodeOwner, "disposeNodeOwner");
+
+// 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 owner = getCurrentOwner();
+  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;
+      if (owner) owner.run(() => factory(nextParent, end));
+      else 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/runtime/src/dynamic.ts
+function insertDynamic(parent, anchor, factory) {
+  const marker = createComment("vobs:dynamic");
+  insertBefore(parent, marker, anchor);
+  let current = null;
+  effect(() => {
+    const next = createBlock(factory);
+    if (next === current) return;
+    if (current) removeChild(parent, current);
+    current = next;
+    if (current) insertBefore(parent, current, marker);
+  });
+}
+__name(insertDynamic, "insertDynamic");
+
+// 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 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 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");
+
+// packages/table/src/column-settings.ts
+function KitColumnSettings(props = {}) {
+  const root = createElement("details");
+  const summary = createElement("summary");
+  const panel = createElement("div");
+  const columns = readColumns(props);
+  const internalSettings = state(untrack(() => initialSettings(props, columns)));
+  const panelOpen = state(false);
+  untrack(() => restoreSettings(props, columns, internalSettings));
+  effect(() => {
+    currentSettings(props, internalSettings, columns);
+    if (panelOpen.value) setProperty(root, "open", true);
+  });
+  bindClassList(root, props, () => ["vobs-column-settings"]);
+  bindCommonAttributes(root, props, [
+    "columns",
+    "settings",
+    "persistence",
+    "visibleColumnIds",
+    "trigger",
+    "label",
+    "closeLabel",
+    "resetLabel",
+    "onChange",
+    "onSettingsChange",
+    "onReset",
+    "onPersistenceError"
+  ]);
+  setAttribute(summary, "class", "vobs-column-settings__trigger");
+  setAttribute(panel, "class", "vobs-column-settings__panel");
+  setAttribute(panel, "role", "group");
+  addEventListener(summary, "click", (event) => {
+    event.preventDefault();
+    panelOpen.value = !root.open;
+    setProperty(root, "open", panelOpen.value);
+  });
+  if (hasProp(props, "trigger")) {
+    insertDynamic(summary, null, () => resolveSlot(readProp(props, "trigger", void 0)));
+  } else {
+    const label = createText("");
+    bindText2(label, () => readProp(props, "label", "Columns"));
+    insertBefore(summary, label, null);
+  }
+  insertDynamic(panel, null, () => createColumnOptions(props, internalSettings, columns, root));
+  insertBefore(root, summary, null);
+  insertBefore(root, panel, null);
+  return root;
+}
+__name(KitColumnSettings, "KitColumnSettings");
+function createColumnOptions(props, internalSettings, columns, root) {
+  const settings = currentSettings(props, internalSettings, columns);
+  return createFragment((parent, anchor) => {
+    const reset = createElement("button");
+    const resetLabel = createText("");
+    setAttribute(reset, "type", "button");
+    setAttribute(reset, "class", "vobs-column-settings__reset");
+    bindText2(resetLabel, () => readProp(props, "resetLabel", "Reset columns"));
+    addEventListener(reset, "click", (event) => {
+      event.preventDefault();
+      event.stopPropagation();
+      resetSettings(props, internalSettings, columns, root);
+    });
+    insertBefore(reset, resetLabel, null);
+    insertBefore(parent, reset, anchor);
+    const visibility = createElement("div");
+    setAttribute(visibility, "class", "vobs-column-settings__visibility");
+    for (const column of columns) {
+      insertBefore(visibility, createVisibilityOption(props, internalSettings, columns, column), null);
+    }
+    insertBefore(parent, visibility, anchor);
+    const layout = createElement("div");
+    setAttribute(layout, "class", "vobs-column-settings__layout");
+    const ordered = orderColumns(columns, settings.columnOrder);
+    for (const [index, column] of ordered.entries()) {
+      insertBefore(layout, createLayoutOption(
+        props,
+        internalSettings,
+        columns,
+        column,
+        root,
+        index === 0,
+        index === ordered.length - 1
+      ), null);
+    }
+    insertBefore(parent, layout, anchor);
+  });
+}
+__name(createColumnOptions, "createColumnOptions");
+function createVisibilityOption(props, internalSettings, columns, column) {
+  const option = createElement("label");
+  const input = createElement("input");
+  const text = createText(column.label);
+  const settings = currentSettings(props, internalSettings, columns);
+  setAttribute(option, "class", "vobs-column-settings__option");
+  setAttribute(input, "type", "checkbox");
+  setProperty(input, "checked", settings.visibleColumnIds.includes(column.id));
+  setProperty(input, "disabled", settings.visibleColumnIds.length <= 1 && input.checked);
+  addEventListener(input, "change", () => {
+    const current = currentSettings(props, internalSettings, columns);
+    const visible = new Set(current.visibleColumnIds);
+    if (input.checked) visible.add(column.id);
+    else if (visible.size > 1) visible.delete(column.id);
+    const ordered = orderColumns(columns, current.columnOrder);
+    const nextIds = ordered.filter((candidate) => visible.has(candidate.id)).map((candidate) => candidate.id);
+    commitSettings(props, internalSettings, columns, {
+      ...current,
+      visibleColumnIds: nextIds
+    });
+  });
+  insertBefore(option, input, null);
+  insertBefore(option, text, null);
+  return option;
+}
+__name(createVisibilityOption, "createVisibilityOption");
+function createLayoutOption(props, internalSettings, columns, column, root, isFirst, isLast) {
+  const option = createElement("div");
+  const label = createElement("span");
+  const controls = createElement("div");
+  const up = createMoveButton("up", column.label, isFirst);
+  const down = createMoveButton("down", column.label, isLast);
+  const width = createElement("input");
+  const current = currentSettings(props, internalSettings, columns);
+  const configuredWidth = current.columnWidths[column.id] ?? column.width;
+  setAttribute(option, "class", "vobs-column-settings__layout-option");
+  setAttribute(option, "data-column-id", column.id);
+  setAttribute(label, "class", "vobs-column-settings__layout-label");
+  setProperty(label, "textContent", column.label);
+  setAttribute(controls, "class", "vobs-column-settings__layout-controls");
+  setAttribute(width, "type", "text");
+  setAttribute(width, "class", "vobs-column-settings__width");
+  setAttribute(width, "placeholder", "auto");
+  setAttribute(width, "aria-label", `${column.label} width`);
+  setProperty(width, "value", displayWidth(configuredWidth));
+  addEventListener(up, "click", (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    moveColumn(props, internalSettings, columns, column.id, -1, root);
+  });
+  addEventListener(down, "click", (event) => {
+    event.preventDefault();
+    event.stopPropagation();
+    moveColumn(props, internalSettings, columns, column.id, 1, root);
+  });
+  const commitWidth = /* @__PURE__ */ __name(() => {
+    const value = width.value.trim();
+    const currentSettingsValue = currentSettings(props, internalSettings, columns);
+    const currentWidth = displayWidth(currentSettingsValue.columnWidths[column.id] ?? column.width);
+    if (value === currentWidth) return;
+    if (value && !isColumnWidthValue(value)) {
+      width.value = currentWidth;
+      return;
+    }
+    const nextWidths = { ...currentSettingsValue.columnWidths };
+    if (value) nextWidths[column.id] = value;
+    else delete nextWidths[column.id];
+    commitSettings(props, internalSettings, columns, {
+      ...currentSettingsValue,
+      columnWidths: nextWidths
+    });
+  }, "commitWidth");
+  addEventListener(width, "change", commitWidth);
+  addEventListener(width, "blur", commitWidth);
+  addEventListener(width, "keydown", (event) => {
+    if (event.key !== "Enter") return;
+    event.preventDefault();
+    commitWidth();
+  });
+  insertBefore(controls, up, null);
+  insertBefore(controls, down, null);
+  insertBefore(controls, width, null);
+  insertBefore(option, label, null);
+  insertBefore(option, controls, null);
+  return option;
+}
+__name(createLayoutOption, "createLayoutOption");
+function createMoveButton(direction, columnLabel, disabled) {
+  const button = createElement("button");
+  setAttribute(button, "type", "button");
+  setAttribute(button, "class", `vobs-column-settings__move vobs-column-settings__move--${direction}`);
+  setAttribute(button, "aria-label", `Move ${columnLabel} ${direction}`);
+  setAttribute(button, "title", `Move ${columnLabel} ${direction}`);
+  setProperty(button, "disabled", disabled);
+  insertBefore(button, createText(direction === "up" ? "\u2191" : "\u2193"), null);
+  return button;
+}
+__name(createMoveButton, "createMoveButton");
+function moveColumn(props, internalSettings, columns, columnId, offset, root) {
+  const current = currentSettings(props, internalSettings, columns);
+  const order = [...current.columnOrder];
+  const index = order.indexOf(columnId);
+  const target = index + offset;
+  if (index < 0 || target < 0 || target >= order.length) return;
+  [order[index], order[target]] = [order[target], order[index]];
+  commitSettings(props, internalSettings, columns, { ...current, columnOrder: order });
+  reopenPanel(root);
+}
+__name(moveColumn, "moveColumn");
+function resetSettings(props, internalSettings, columns, root) {
+  const persistence = readProp(props, "persistence", void 0);
+  let cleared = false;
+  if (persistence?.reset) {
+    try {
+      persistence.reset();
+      cleared = true;
+    } catch (error) {
+      reportPersistenceError(props, error);
+    }
+  }
+  const defaults = createDefaultColumnSettings(columns);
+  commitSettings(props, internalSettings, columns, defaults, !persistence || !cleared);
+  reopenPanel(root);
+  readProp(props, "onReset", void 0)?.();
+}
+__name(resetSettings, "resetSettings");
+function commitSettings(props, internalSettings, columns, settings, persist = true) {
+  const normalized = normalizeColumnSettings(columns, settings);
+  if (!isControlled(props)) internalSettings.value = normalized;
+  if (persist) saveSettings(props, normalized);
+  readProp(props, "onSettingsChange", void 0)?.(normalized);
+  readProp(props, "onChange", void 0)?.(normalized.visibleColumnIds);
+}
+__name(commitSettings, "commitSettings");
+function initialSettings(props, columns) {
+  const settings = readProp(props, "settings", void 0);
+  if (settings !== void 0) return normalizeColumnSettings(columns, settings);
+  return normalizeColumnSettings(
+    columns,
+    void 0,
+    readProp(props, "visibleColumnIds", void 0)
+  );
+}
+__name(initialSettings, "initialSettings");
+function restoreSettings(props, columns, internalSettings) {
+  if (isControlled(props)) return;
+  const persistence = readProp(props, "persistence", void 0);
+  if (!persistence) return;
+  try {
+    const stored = persistence.load();
+    if (stored) internalSettings.value = normalizeColumnSettings(columns, stored);
+  } catch (error) {
+    reportPersistenceError(props, error);
+  }
+}
+__name(restoreSettings, "restoreSettings");
+function currentSettings(props, internalSettings, columns) {
+  const external = readProp(props, "settings", void 0);
+  if (external !== void 0) return normalizeColumnSettings(columns, external);
+  const visibleColumnIds = readProp(props, "visibleColumnIds", void 0);
+  if (visibleColumnIds !== void 0) {
+    return normalizeColumnSettings(columns, {
+      ...internalSettings.value,
+      visibleColumnIds
+    });
+  }
+  return normalizeColumnSettings(columns, internalSettings.value);
+}
+__name(currentSettings, "currentSettings");
+function saveSettings(props, settings) {
+  const persistence = readProp(props, "persistence", void 0);
+  if (!persistence) return;
+  try {
+    persistence.save(settings);
+  } catch (error) {
+    reportPersistenceError(props, error);
+  }
+}
+__name(saveSettings, "saveSettings");
+function readColumns(props) {
+  return readProp(props, "columns", []);
+}
+__name(readColumns, "readColumns");
+function displayWidth(value) {
+  if (value === void 0) return "";
+  return typeof value === "number" ? `${value}px` : value;
+}
+__name(displayWidth, "displayWidth");
+function isControlled(props) {
+  return isProvided(props, "settings") || isProvided(props, "visibleColumnIds");
+}
+__name(isControlled, "isControlled");
+function isProvided(props, name) {
+  return hasProp(props, name) && Reflect.get(props, name) !== void 0;
+}
+__name(isProvided, "isProvided");
+function reportPersistenceError(props, error) {
+  readProp(props, "onPersistenceError", void 0)?.(error);
+}
+__name(reportPersistenceError, "reportPersistenceError");
+function reopenPanel(root) {
+  setTimeout(() => {
+    setProperty(root, "open", true);
+  }, 0);
+}
+__name(reopenPanel, "reopenPanel");
+
+export { KitColumnSettings };
+//# sourceMappingURL=column-settings.js.map
+//# sourceMappingURL=column-settings.js.map