nuxt-ui-tools 0.1.0

package/dist/runtime/table/utils/actions.js

@@ -0,0 +1,101 @@
+export function resolveTableRowActions(options) {
+  const source = options.schema.rowActions;
+  if (!source) return [];
+  if (typeof source === "function") return source(options.scope);
+  return source;
+}
+export function resolveVisibleTableRowActions(options) {
+  return pruneTableRowActions({
+    actions: resolveTableRowActions(options),
+    scope: options.scope
+  });
+}
+export function hasVisibleTableRowActions(options) {
+  return options.rows.some(
+    (row, index) => resolveVisibleTableRowActions({
+      schema: options.schema,
+      scope: {
+        row,
+        index,
+        context: toPlainRecord(options.context),
+        pageContext: toPlainRecord(options.pageContext),
+        tableApi: options.tableApi,
+        layout: options.layout
+      }
+    }).length > 0
+  );
+}
+export function createRowActionDropdownItems(options) {
+  return options.actions.map(
+    (action) => mapRowActionToDropdownItem({ action, scope: options.scope })
+  );
+}
+function mapRowActionToDropdownItem(options) {
+  const children = options.action.children ? createRowActionDropdownItems({
+    actions: options.action.children,
+    scope: options.scope
+  }) : void 0;
+  const item = {
+    ...options.action,
+    label: resolveActionLabel(options.action),
+    disabled: resolveFlag({
+      value: options.action.disabled,
+      scope: options.scope
+    }),
+    loading: resolveFlag({
+      value: options.action.loading,
+      scope: options.scope
+    }),
+    children: children?.length ? children : void 0,
+    onSelect: () => {
+      void options.action.action?.(options.scope);
+    }
+  };
+  delete item.condition;
+  delete item.action;
+  return item;
+}
+function resolveActionLabel(action) {
+  if (typeof action.label === "function") return String(action.label());
+  if (typeof action.label === "number") return String(action.label);
+  return action.label;
+}
+function resolveConditionalBoolean(options) {
+  if (typeof options.value === "function") return options.value(options.scope);
+  return options.value ?? true;
+}
+function resolveCondition(options) {
+  return resolveConditionalBoolean(options);
+}
+function resolveFlag(options) {
+  if (typeof options.value === "function") return options.value(options.scope);
+  return options.value ?? false;
+}
+function pruneTableRowActions(options) {
+  return options.actions.flatMap((action) => {
+    if (!resolveCondition({ value: action.condition, scope: options.scope })) return [];
+    const children = action.children ? pruneTableRowActions({
+      actions: action.children,
+      scope: options.scope
+    }) : void 0;
+    const nextAction = children ? { ...action, children } : action;
+    if (!children?.length && !isActionItemSelectable(nextAction)) return [];
+    return [
+      {
+        ...nextAction,
+        children: children?.length ? children : void 0
+      }
+    ];
+  });
+}
+function isActionItemSelectable(action) {
+  if (action.action) return true;
+  if (action.href) return true;
+  if (action.to) return true;
+  if (action.type === "checkbox") return true;
+  if (action.onUpdateChecked) return true;
+  return false;
+}
+function toPlainRecord(value) {
+  return Object.fromEntries(Object.entries(value));
+}

package/dist/runtime/table/utils/client-query.d.ts

@@ -0,0 +1,25 @@
+import type { TableFacetExecutionResult, TableFacetRequestDescriptor, GenericObject, TableResolvedFilterGroup, TableSourceExecutionResult, TableSourceRequestContext, TableSortingRule } from '../types/index.js';
+export interface TableClientQueryParams<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject> {
+    rows: Iterable<TRow>;
+    request: TableSourceRequestContext<TRow, TContext>;
+}
+export declare function executeClientQuery<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject>(params: TableClientQueryParams<TRow, TContext>): TableSourceExecutionResult<TRow>;
+export interface TableClientFacetParams<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject> {
+    rows: Iterable<TRow>;
+    request: TableSourceRequestContext<TRow, TContext>;
+    facets: TableFacetRequestDescriptor<string>[];
+}
+export declare function executeClientFacets<TRow extends GenericObject = GenericObject, TContext extends GenericObject = GenericObject>(params: TableClientFacetParams<TRow, TContext>): TableFacetExecutionResult<string>;
+export declare function filterClientRows<TRow extends GenericObject>(params: {
+    rows: Iterable<TRow>;
+    filters: TableResolvedFilterGroup<string>;
+    search: TableSourceRequestContext<TRow>['search'];
+}): TRow[];
+export declare function sortClientRows<TRow extends GenericObject>(params: {
+    rows: Iterable<TRow>;
+    sorting: TableSortingRule[];
+}): TRow[];
+export declare function paginateClientRows<TRow extends GenericObject>(params: {
+    rows: Iterable<TRow>;
+    pagination: TableSourceRequestContext<TRow>['pagination'];
+}): TableSourceExecutionResult<TRow, string>;

package/dist/runtime/table/utils/client-query.js

@@ -0,0 +1,474 @@
+import { isArray, isDate, isObject, isString } from "../../shared/utils/predicate.js";
+export function executeClientQuery(params) {
+  const filteredRows = filterClientRows({
+    rows: params.rows,
+    filters: params.request.filters,
+    search: params.request.search
+  });
+  const sortedRows = sortClientRows({
+    rows: filteredRows,
+    sorting: params.request.sorting
+  });
+  return paginateClientRows({
+    rows: sortedRows,
+    pagination: params.request.pagination
+  });
+}
+export function executeClientFacets(params) {
+  return {
+    facets: params.facets.map(
+      (facet) => resolveClientFacet({
+        rows: params.rows,
+        request: params.request,
+        facet
+      })
+    )
+  };
+}
+export function filterClientRows(params) {
+  return [
+    ...lazyFilterRows(params.rows, {
+      filters: params.filters,
+      search: params.search
+    })
+  ];
+}
+export function sortClientRows(params) {
+  return [...lazySortRows(params.rows, params.sorting)];
+}
+export function paginateClientRows(params) {
+  return paginateRows(params.rows, params.pagination);
+}
+function* lazyFilterRows(rows, params) {
+  for (const row of rows) {
+    if (matchesSearch(row, params.search) && matchesFilterNode(row, params.filters)) {
+      yield row;
+    }
+  }
+}
+function resolveClientFacet(options) {
+  const matchingRows = lazyFilterRows(options.rows, {
+    filters: options.facet.mode === "include-self" ? options.request.filters : removeFilterKeyFromGroup({
+      group: options.request.filters,
+      key: options.facet.key
+    }),
+    search: options.request.search
+  });
+  const counts = countFacetOptions({
+    rows: matchingRows,
+    key: options.facet.key,
+    search: options.facet.search
+  });
+  const start = resolveFacetOffset(options.facet.cursor);
+  const limited = options.facet.limit ? counts.slice(start, start + options.facet.limit) : counts.slice(start);
+  return {
+    key: options.facet.key,
+    options: limited,
+    nextCursor: options.facet.limit && start + options.facet.limit < counts.length ? String(start + options.facet.limit) : null,
+    total: counts.length
+  };
+}
+function matchesSearch(row, search) {
+  if (!search.value.trim().length || !search.fields.length) {
+    return true;
+  }
+  return search.fields.some(
+    (field) => pathMatchesSearchValue({
+      value: row,
+      path: String(field),
+      search: search.value
+    })
+  );
+}
+function pathMatchesSearchValue(options) {
+  const segments = options.path.split(".");
+  return matchSearchPathSegments({
+    value: options.value,
+    segments,
+    search: options.search
+  });
+}
+function matchSearchPathSegments(options) {
+  if (options.segments.length === 0) {
+    return valueMatchesSearch({
+      value: options.value,
+      search: options.search
+    });
+  }
+  if (isArray(options.value)) {
+    return options.value.some(
+      (item) => matchSearchPathSegments({
+        value: item,
+        segments: options.segments,
+        search: options.search
+      })
+    );
+  }
+  if (!isObject(options.value)) {
+    return false;
+  }
+  const [head, ...tail] = options.segments;
+  if (!head || !(head in options.value)) {
+    return false;
+  }
+  return matchSearchPathSegments({
+    value: options.value[head],
+    segments: tail,
+    search: options.search
+  });
+}
+function valueMatchesSearch(options) {
+  const normalizedSearch = normalizeString(options.search);
+  if (isArray(options.value)) {
+    return options.value.some(
+      (item) => valueMatchesSearch({
+        value: item,
+        search: normalizedSearch
+      })
+    );
+  }
+  return normalizeString(options.value).includes(normalizedSearch);
+}
+function* lazySortRows(rows, sorting = []) {
+  if (!sorting.length) {
+    yield* rows;
+    return;
+  }
+  const buffer = [];
+  const iterator = rows[Symbol.iterator]();
+  const compare = createRowComparator(sorting);
+  while (buffer.length < 1e3) {
+    const next = iterator.next();
+    if (next.done) break;
+    buffer.push(next.value);
+  }
+  buffer.sort(compare);
+  let cursor = 0;
+  while (cursor < buffer.length) {
+    yield buffer[cursor++];
+    while (buffer.length < cursor + 1e3) {
+      const next = iterator.next();
+      if (next.done) break;
+      const insertIndex = findInsertIndex({
+        rows: buffer,
+        value: next.value,
+        compare,
+        offset: cursor
+      });
+      buffer.splice(insertIndex, 0, next.value);
+    }
+  }
+}
+function createRowComparator(sorting) {
+  return (left, right) => {
+    for (const rule of sorting) {
+      const direction = rule.dir === "desc" ? -1 : 1;
+      const comparison = compareUnknownValues({
+        left: getFilterTargetValue({ source: left, key: rule.key }),
+        right: getFilterTargetValue({ source: right, key: rule.key })
+      });
+      if (comparison !== 0) return comparison * direction;
+    }
+    return 0;
+  };
+}
+function findInsertIndex(options) {
+  const offset = options.offset ?? 0;
+  let low = offset;
+  let high = options.rows.length;
+  while (low < high) {
+    const mid = Math.floor((low + high) / 2);
+    if (options.compare(options.value, options.rows[mid]) < 0) {
+      high = mid;
+      continue;
+    }
+    low = mid + 1;
+  }
+  return low;
+}
+function paginateRows(rows, pagination) {
+  if (pagination.mode !== "offset") {
+    const collected2 = [...rows];
+    return { rows: collected2, rowCount: collected2.length };
+  }
+  const pageIndex = Math.max(1, pagination.pageIndex || 1);
+  const pageSize = Math.max(1, pagination.pageSize || 1);
+  const start = (pageIndex - 1) * pageSize;
+  const collected = [];
+  let index = 0;
+  let remaining = 0;
+  for (const row of rows) {
+    if (index < start) {
+      index++;
+      continue;
+    }
+    if (collected.length < pageSize) {
+      collected.push(row);
+      index++;
+      continue;
+    }
+    remaining++;
+  }
+  return {
+    rows: collected,
+    rowCount: index + remaining
+  };
+}
+function removeFilterKeyFromGroup(options) {
+  const children = [];
+  for (const child of options.group.children) {
+    if (child.type === "condition") {
+      if (child.key !== options.key) children.push(child);
+      continue;
+    }
+    const nextGroup = removeFilterKeyFromGroup({
+      group: child,
+      key: options.key
+    });
+    if (nextGroup.children.length) children.push(nextGroup);
+  }
+  return {
+    ...options.group,
+    children
+  };
+}
+function countFacetOptions(options) {
+  const countByValue = /* @__PURE__ */ new Map();
+  const normalizedSearch = options.search?.trim().toLocaleLowerCase() ?? "";
+  for (const row of options.rows) {
+    const seenInRow = /* @__PURE__ */ new Set();
+    for (const value of toValueList(getFilterTargetValue({ source: row, key: options.key }))) {
+      if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean")
+        continue;
+      const searchValue = String(value).toLocaleLowerCase();
+      if (normalizedSearch.length && !searchValue.includes(normalizedSearch)) continue;
+      const mapKey = `${typeof value}:${String(value)}`;
+      if (seenInRow.has(mapKey)) continue;
+      seenInRow.add(mapKey);
+      const current = countByValue.get(mapKey);
+      if (current) {
+        current.count += 1;
+        continue;
+      }
+      countByValue.set(mapKey, {
+        value,
+        count: 1
+      });
+    }
+  }
+  return [...countByValue.values()].sort(compareFacetOptions);
+}
+function compareFacetOptions(left, right) {
+  if (left.count !== right.count) return right.count - left.count;
+  return compareUnknownValues({ left: left.value, right: right.value });
+}
+function resolveFacetOffset(cursor) {
+  if (!cursor) return 0;
+  const value = Number(cursor);
+  return Number.isFinite(value) && value > 0 ? value : 0;
+}
+function matchesFilterNode(row, node) {
+  if (node.type === "group") {
+    if (!node.children.length) {
+      return true;
+    }
+    return node.combinator === "and" ? node.children.every((child) => matchesFilterNode(row, child)) : node.children.some((child) => matchesFilterNode(row, child));
+  }
+  return matchesFilterCondition(row, node);
+}
+function matchesFilterCondition(row, condition) {
+  const value = getFilterTargetValue({
+    source: row,
+    key: condition.key
+  });
+  switch (condition.operator) {
+    case "contains":
+      return matchContains({ value, filter: condition.value });
+    case "is":
+      return matchIs({ value, filter: condition.value });
+    case "isAnyOf":
+      return matchIsAnyOf({ value, filter: condition.value });
+    case "isNot":
+      return !matchIs({ value, filter: condition.value });
+    case "gt":
+      return matchComparison({ value, filter: condition.value, operator: "gt" });
+    case "gte":
+      return matchComparison({ value, filter: condition.value, operator: "gte" });
+    case "lt":
+      return matchComparison({ value, filter: condition.value, operator: "lt" });
+    case "lte":
+      return matchComparison({ value, filter: condition.value, operator: "lte" });
+    case "between":
+      return matchBetween({ value, filter: condition.value });
+    case "before":
+      return matchComparison({ value, filter: condition.value, operator: "lt" });
+    case "after":
+      return matchComparison({ value, filter: condition.value, operator: "gt" });
+    default:
+      return false;
+  }
+}
+function getFilterTargetValue(options) {
+  return options.key.split(".").reduce((current, segment) => {
+    if (isArray(current)) {
+      return current.map(
+        (item) => item != null && typeof item === "object" ? item[segment] : void 0
+      );
+    }
+    if (!current || typeof current !== "object") {
+      return void 0;
+    }
+    return current[segment];
+  }, options.source);
+}
+function matchContains(options) {
+  const needle = normalizeString(options.filter);
+  if (!needle.length) {
+    return true;
+  }
+  return toValueList(options.value).some((item) => normalizeString(item).includes(needle));
+}
+function matchIs(options) {
+  return toValueList(options.value).some(
+    (item) => areEqual({
+      left: item,
+      right: options.filter
+    })
+  );
+}
+function matchIsAnyOf(options) {
+  if (!isArray(options.filter)) {
+    return matchIs(options);
+  }
+  return options.filter.some(
+    (candidate) => matchIs({
+      value: options.value,
+      filter: candidate
+    })
+  );
+}
+function matchBetween(options) {
+  if (!isObject(options.filter)) {
+    return false;
+  }
+  const from = "from" in options.filter ? normalizeComparable(options.filter.from) : null;
+  const to = "to" in options.filter ? normalizeComparable(options.filter.to) : null;
+  return toValueList(options.value).some((item) => {
+    const comparable = normalizeComparable(item);
+    if (comparable == null) {
+      return false;
+    }
+    if (from != null && comparable < from) {
+      return false;
+    }
+    if (to != null && comparable > to) {
+      return false;
+    }
+    return true;
+  });
+}
+function matchComparison(options) {
+  const expected = normalizeComparable(options.filter);
+  if (expected == null) {
+    return false;
+  }
+  return toValueList(options.value).some((item) => {
+    const comparable = normalizeComparable(item);
+    if (comparable == null) {
+      return false;
+    }
+    switch (options.operator) {
+      case "gt":
+        return comparable > expected;
+      case "gte":
+        return comparable >= expected;
+      case "lt":
+        return comparable < expected;
+      case "lte":
+        return comparable <= expected;
+    }
+  });
+}
+function toValueList(value) {
+  if (!isArray(value)) {
+    return [value];
+  }
+  return value.flatMap((item) => isArray(item) ? toValueList(item) : [item]);
+}
+function areEqual(options) {
+  if (isDate(options.left) || isDate(options.right)) {
+    const leftValue = normalizeComparable(options.left);
+    const rightValue = normalizeComparable(options.right);
+    return leftValue != null && leftValue === rightValue;
+  }
+  return options.left === options.right;
+}
+function compareUnknownValues(options) {
+  const leftComparable = normalizeComparableForSort(options.left);
+  const rightComparable = normalizeComparableForSort(options.right);
+  if (leftComparable == null && rightComparable == null) {
+    return 0;
+  }
+  if (leftComparable == null) {
+    return 1;
+  }
+  if (rightComparable == null) {
+    return -1;
+  }
+  if (typeof leftComparable === "string" && typeof rightComparable === "string") {
+    return leftComparable.localeCompare(rightComparable, void 0, {
+      numeric: true,
+      sensitivity: "base"
+    });
+  }
+  if (leftComparable === rightComparable) {
+    return 0;
+  }
+  return leftComparable < rightComparable ? -1 : 1;
+}
+function normalizeComparableForSort(value) {
+  if (isArray(value)) {
+    return normalizeComparableForSort(value[0]);
+  }
+  if (isDate(value)) {
+    return value.getTime();
+  }
+  if (typeof value === "number") {
+    return Number.isNaN(value) ? null : value;
+  }
+  if (typeof value === "boolean") {
+    return value ? 1 : 0;
+  }
+  if (isString(value)) {
+    return value.toLocaleLowerCase();
+  }
+  if (value == null) {
+    return null;
+  }
+  return String(value).toLocaleLowerCase();
+}
+function normalizeComparable(value) {
+  if (isDate(value)) {
+    return value.getTime();
+  }
+  if (typeof value === "number") {
+    return Number.isNaN(value) ? null : value;
+  }
+  if (typeof value === "string") {
+    const maybeTimestamp = Date.parse(value);
+    if (!Number.isNaN(maybeTimestamp) && /\d{4}-\d{2}-\d{2}/.test(value)) {
+      return maybeTimestamp;
+    }
+    return value.toLocaleLowerCase();
+  }
+  if (typeof value === "boolean") {
+    return value ? 1 : 0;
+  }
+  return null;
+}
+function normalizeString(value) {
+  if (value == null) {
+    return "";
+  }
+  return String(value).toLocaleLowerCase();
+}

package/dist/runtime/table/utils/columns/index.d.ts

@@ -0,0 +1,5 @@
+export * from './menu.js';
+export * from './render.js';
+export * from './schema.js';
+export * from './state.js';
+export * from './types.js';

package/dist/runtime/table/utils/columns/index.js

@@ -0,0 +1,5 @@
+export * from "./menu.js";
+export * from "./render.js";
+export * from "./schema.js";
+export * from "./state.js";
+export * from "./types.js";

package/dist/runtime/table/utils/columns/menu.d.ts

@@ -0,0 +1,47 @@
+import type { TableSchemaView } from '../../types/index.js';
+export declare function createColumnMenuItems(options: {
+    columnId: string;
+    schema: TableSchemaView;
+    orderedColumns: Array<{
+        id: string;
+        sortableKey?: string;
+    }>;
+    getSortState: (options: {
+        columnId: string;
+    }) => 'asc' | 'desc' | null;
+    getPinnedState: (options: {
+        columnId: string;
+    }) => 'left' | 'right' | null;
+    setPinning: (options: {
+        columnId: string;
+        pinned?: 'left' | 'right';
+    }) => void;
+    setVisibility: (options: {
+        columnId: string;
+        visible: boolean;
+    }) => void;
+    setSorting: (options: {
+        key: string;
+        dir: 'asc' | 'desc';
+    } | null) => void;
+}): ({
+    label: string;
+    icon: string;
+    color: string;
+    onSelect: () => void;
+} | {
+    label: string;
+    icon: string;
+    onSelect: () => void;
+    color?: undefined;
+})[][];
+export declare function getColumnHeaderIcon(options: {
+    columnId: string;
+    getSortState: (options: {
+        columnId: string;
+    }) => 'asc' | 'desc' | null;
+    getPinnedState: (options: {
+        columnId: string;
+    }) => 'left' | 'right' | null;
+    canHide?: boolean;
+}): "i-lucide-arrow-up" | "i-lucide-arrow-down" | "i-lucide-chevrons-up-down" | "i-lucide-grip-vertical";