nuxt-ui-tools 0.1.0

package/dist/runtime/table/utils/filters/common.js

@@ -0,0 +1,131 @@
+import { useUiToolsLocale } from "#ui-tools/i18n";
+import { isArray, isObject } from "../../../shared/utils/predicate.js";
+import { resolveTextValue } from "../../../shared/utils/render.js";
+export function getFilterLabelText(options) {
+  if (typeof options.label === "number") return String(options.label);
+  if (typeof options.label === "string") return options.label;
+  const resolved = options.label();
+  return typeof resolved === "string" || typeof resolved === "number" ? String(resolved) : "";
+}
+export function getFilterTextValue(options) {
+  return resolveTextValue(options.value, options.fallback);
+}
+export function getFilterRuleValue(options) {
+  return options.rule?.value;
+}
+export function getFilterPathValues(options) {
+  return flattenFilterValues({
+    value: readFilterPathValue({
+      source: options.source,
+      key: options.key
+    })
+  });
+}
+export function readFilterPathValue(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);
+}
+export function flattenFilterValues(options) {
+  if (isArray(options.value)) {
+    return options.value.flatMap(
+      (item) => flattenFilterValues({
+        value: item
+      })
+    );
+  }
+  if (options.value == null) {
+    return [];
+  }
+  return [options.value];
+}
+export function isDateRangeValue(options) {
+  if (!options.value || !isObject(options.value) || isArray(options.value)) {
+    return false;
+  }
+  return "from" in options.value || "to" in options.value;
+}
+export function toDateFilterValue(options) {
+  if (options.value instanceof Date) {
+    return options.value;
+  }
+  if (typeof options.value === "string" || typeof options.value === "number") {
+    const date = new Date(options.value);
+    return Number.isNaN(date.getTime()) ? void 0 : date;
+  }
+  const rangeValue = getDateRangeValue({
+    value: options.value
+  });
+  if (rangeValue) {
+    const from = toMaybeDate({
+      value: rangeValue.from
+    });
+    return from && !Number.isNaN(from.getTime()) ? from : void 0;
+  }
+  return void 0;
+}
+export function formatFilterDate(options) {
+  const { locale } = useUiToolsLocale();
+  return new Intl.DateTimeFormat(locale.value.code, {
+    month: "short",
+    day: "numeric",
+    year: "numeric"
+  }).format(options.value);
+}
+export function isFilterValueSelected(options) {
+  return options.values.some(
+    (value) => areFilterValuesEqual({ left: value, right: options.candidate })
+  );
+}
+export function getDateRangeValue(options) {
+  return isDateRangeValue({ value: options.value }) ? options.value : void 0;
+}
+function isNumberRangeValue(options) {
+  if (!options.value || !isObject(options.value) || isArray(options.value)) {
+    return false;
+  }
+  return "from" in options.value || "to" in options.value;
+}
+export function getNumberRangeValue(options) {
+  return isNumberRangeValue({ value: options.value }) ? options.value : void 0;
+}
+export function formatFilterNumber(options) {
+  const { locale } = useUiToolsLocale();
+  return new Intl.NumberFormat(locale.value.code).format(options.value);
+}
+export function toMaybeNumber(options) {
+  if (typeof options.value === "number") {
+    return options.value;
+  }
+  if (typeof options.value === "string") {
+    const n = Number(options.value);
+    return Number.isNaN(n) ? void 0 : n;
+  }
+  return void 0;
+}
+export function toMaybeDate(options) {
+  if (options.value instanceof Date) {
+    return options.value;
+  }
+  if (typeof options.value === "string" || typeof options.value === "number") {
+    const date = new Date(options.value);
+    return Number.isNaN(date.getTime()) ? void 0 : date;
+  }
+  return void 0;
+}
+function areFilterValuesEqual(options) {
+  if (options.left instanceof Date || options.right instanceof Date) {
+    const left = options.left instanceof Date ? options.left : options.left != null ? new Date(String(options.left)) : void 0;
+    const right = options.right instanceof Date ? options.right : options.right != null ? new Date(String(options.right)) : void 0;
+    return left?.getTime() === right?.getTime();
+  }
+  return String(options.left) === String(options.right);
+}

package/dist/runtime/table/utils/filters/date.d.ts

@@ -0,0 +1,28 @@
+import type { TableDateFilterDefinition, TableDateFilterOperator, TableScalarDateFilterOperator } from '../../types/index.js';
+export interface ResolvedTableDateFilterScalarPreset {
+    label: string;
+    description?: string;
+    value: Date;
+}
+export interface ResolvedTableDateFilterRangePreset {
+    label: string;
+    description?: string;
+    value: {
+        from?: Date;
+        to?: Date;
+    };
+}
+export declare function resolveDateFilterScalarPresets(options: {
+    definition: TableDateFilterDefinition;
+    operator: TableScalarDateFilterOperator;
+    now?: Date;
+}): ResolvedTableDateFilterScalarPreset[];
+export declare function resolveDateFilterRangePresets(options: {
+    definition: TableDateFilterDefinition;
+    now?: Date;
+}): ResolvedTableDateFilterRangePreset[];
+export declare function resolveDateFilterRangeCalendarPanels(options: {
+    definition: TableDateFilterDefinition;
+    mobile: boolean;
+}): 1 | 2;
+export declare function resolveDateFilterOperatorDescription(operator: TableDateFilterOperator | undefined): string;

package/dist/runtime/table/utils/filters/date.js

@@ -0,0 +1,233 @@
+import { resolveTextValue } from "#ui-tools/shared/utils/render";
+import { resolveDateFilterUi } from "./ui.js";
+export function resolveDateFilterScalarPresets(options) {
+  const presetDefinitions = getScalarPresetDefinitions(options);
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  return presetDefinitions.map((preset) => ({
+    label: resolveTextValue(preset.label),
+    ...preset.description ? { description: resolveTextValue(preset.description) } : {},
+    value: resolveScalarPresetValue({
+      preset,
+      now
+    })
+  }));
+}
+export function resolveDateFilterRangePresets(options) {
+  const presetDefinitions = getRangePresetDefinitions(options.definition);
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  return presetDefinitions.map((preset) => ({
+    label: resolveTextValue(preset.label),
+    ...preset.description ? { description: resolveTextValue(preset.description) } : {},
+    value: resolveRangePresetValue({
+      preset,
+      now
+    })
+  }));
+}
+export function resolveDateFilterRangeCalendarPanels(options) {
+  const panels = resolveDateFilterUi(options.definition, "between").range.calendar.months;
+  if (panels === 1 || panels === 2) {
+    return panels;
+  }
+  if (!panels) {
+    return 1;
+  }
+  if (options.mobile) {
+    return panels.mobile ?? panels.desktop ?? 1;
+  }
+  return panels.desktop ?? panels.mobile ?? 2;
+}
+export function resolveDateFilterOperatorDescription(operator) {
+  switch (operator) {
+    case "between":
+      return "Match rows inside a date window.";
+    case "before":
+      return "Match rows before the selected date.";
+    case "after":
+      return "Match rows after the selected date.";
+    case "isNot":
+      return "Exclude rows matching the selected date.";
+    default:
+      return "Match rows on the selected date.";
+  }
+}
+function getScalarPresetDefinitions(options) {
+  const presets = resolveDateFilterUi(options.definition, options.operator).scalar.presets;
+  if (presets === false) return [];
+  if (presets == null) return DEFAULT_SCALAR_PRESETS[options.operator];
+  if (presets === true) return DEFAULT_SCALAR_PRESETS[options.operator];
+  return presets.filter((preset) => {
+    if (!preset.operators?.length) return true;
+    return preset.operators.includes(options.operator);
+  });
+}
+function getRangePresetDefinitions(definition) {
+  const presets = resolveDateFilterUi(definition, "between").range.presets;
+  if (presets === false) return [];
+  if (presets == null) return DEFAULT_RANGE_PRESETS;
+  if (presets === true) return DEFAULT_RANGE_PRESETS;
+  return presets;
+}
+function resolveScalarPresetValue(options) {
+  if (options.preset.value instanceof Date) {
+    return options.preset.value;
+  }
+  return options.preset.value({
+    now: options.now
+  });
+}
+function resolveRangePresetValue(options) {
+  if (typeof options.preset.value === "function") {
+    return options.preset.value({
+      now: options.now
+    });
+  }
+  return options.preset.value;
+}
+function startOfDay(value) {
+  const result = new Date(value);
+  result.setHours(0, 0, 0, 0);
+  return result;
+}
+function endOfDay(value) {
+  const result = new Date(value);
+  result.setHours(23, 59, 59, 999);
+  return result;
+}
+function addDays(value, amount) {
+  const result = new Date(value);
+  result.setDate(result.getDate() + amount);
+  return result;
+}
+function startOfMonth(value) {
+  return new Date(value.getFullYear(), value.getMonth(), 1);
+}
+function endOfMonth(value) {
+  return new Date(value.getFullYear(), value.getMonth() + 1, 0, 23, 59, 59, 999);
+}
+function startOfYear(value) {
+  return new Date(value.getFullYear(), 0, 1);
+}
+const DEFAULT_SCALAR_PRESETS = {
+  is: [
+    {
+      label: "Today",
+      description: "Use the current day.",
+      value: ({ now }) => startOfDay(now)
+    },
+    {
+      label: "Yesterday",
+      description: "Use the previous day.",
+      value: ({ now }) => startOfDay(addDays(now, -1))
+    },
+    {
+      label: "Start of month",
+      description: "Jump to the first day of this month.",
+      value: ({ now }) => startOfMonth(now)
+    }
+  ],
+  isNot: [
+    {
+      label: "Today",
+      description: "Exclude the current day.",
+      value: ({ now }) => startOfDay(now)
+    },
+    {
+      label: "Yesterday",
+      description: "Exclude the previous day.",
+      value: ({ now }) => startOfDay(addDays(now, -1))
+    },
+    {
+      label: "Start of month",
+      description: "Exclude the first day of this month.",
+      value: ({ now }) => startOfMonth(now)
+    }
+  ],
+  before: [
+    {
+      label: "Today",
+      description: "Everything earlier than today.",
+      value: ({ now }) => startOfDay(now)
+    },
+    {
+      label: "7 days ago",
+      description: "Everything earlier than the last 7 days.",
+      value: ({ now }) => startOfDay(addDays(now, -7))
+    },
+    {
+      label: "Start of month",
+      description: "Everything before this month.",
+      value: ({ now }) => startOfMonth(now)
+    }
+  ],
+  after: [
+    {
+      label: "Today",
+      description: "Everything after today.",
+      value: ({ now }) => startOfDay(now)
+    },
+    {
+      label: "7 days ago",
+      description: "Everything after the last 7 days.",
+      value: ({ now }) => startOfDay(addDays(now, -7))
+    },
+    {
+      label: "Start of year",
+      description: "Everything after the first day of this year.",
+      value: ({ now }) => startOfYear(now)
+    }
+  ]
+};
+const DEFAULT_RANGE_PRESETS = [
+  {
+    label: "Today",
+    description: "Only the current day.",
+    value: ({ now }) => ({
+      from: startOfDay(now),
+      to: endOfDay(now)
+    })
+  },
+  {
+    label: "Last 7 days",
+    description: "The previous 7 calendar days.",
+    value: ({ now }) => ({
+      from: startOfDay(addDays(now, -6)),
+      to: endOfDay(now)
+    })
+  },
+  {
+    label: "Last 30 days",
+    description: "The previous 30 calendar days.",
+    value: ({ now }) => ({
+      from: startOfDay(addDays(now, -29)),
+      to: endOfDay(now)
+    })
+  },
+  {
+    label: "This month",
+    description: "From the first day of this month until today.",
+    value: ({ now }) => ({
+      from: startOfMonth(now),
+      to: endOfDay(now)
+    })
+  },
+  {
+    label: "Last month",
+    description: "The full previous month.",
+    value: ({ now }) => {
+      const previousMonth = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+      return {
+        from: startOfMonth(previousMonth),
+        to: endOfMonth(previousMonth)
+      };
+    }
+  },
+  {
+    label: "Year to date",
+    description: "From the first day of the year until today.",
+    value: ({ now }) => ({
+      from: startOfYear(now),
+      to: endOfDay(now)
+    })
+  }
+];

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

@@ -0,0 +1,9 @@
+export * from './common.js';
+export * from './date.js';
+export * from './operators.js';
+export * from './options.js';
+export * from './presentation.js';
+export * from './preview.js';
+export * from './registry.js';
+export * from './tree.js';
+export * from './ui.js';

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

@@ -0,0 +1,9 @@
+export * from "./common.js";
+export * from "./date.js";
+export * from "./operators.js";
+export * from "./options.js";
+export * from "./presentation.js";
+export * from "./preview/index.js";
+export * from "./registry.js";
+export * from "./tree.js";
+export * from "./ui.js";

package/dist/runtime/table/utils/filters/operators.d.ts

@@ -0,0 +1,4 @@
+import type { TableFilterOperator } from '../../types/index.js';
+export declare function getFilterOperatorLabel(options: {
+    operator?: TableFilterOperator;
+}): string;

package/dist/runtime/table/utils/filters/operators.js

@@ -0,0 +1,6 @@
+import { useUiToolsLocale } from "#ui-tools/i18n";
+export function getFilterOperatorLabel(options) {
+  const { t } = useUiToolsLocale();
+  const operator = options.operator ?? "is";
+  return t(`table.filters.operators.${operator}`);
+}

package/dist/runtime/table/utils/filters/options.d.ts

@@ -0,0 +1,20 @@
+import type { TableFilterOptionEntry, TableResolvedFilterOptionEntry, TableUiFilterDefinition } from '../../types/index.js';
+export declare function resolveFilterOptionEntries(options: {
+    definition: TableUiFilterDefinition;
+    rows: unknown[];
+    options?: ReadonlyArray<TableFilterOptionEntry>;
+    selectedValues?: unknown[];
+    deriveCounts?: boolean;
+    facetCounts?: Array<{
+        value: string | number | boolean;
+        count: number;
+    }>;
+    missingCountFallback?: number;
+}): TableResolvedFilterOptionEntry<import("../../types/index.js").TableFilterPrimitiveValue>[] | {
+    id: string;
+    label: string;
+    value: boolean;
+    count: number | undefined;
+    selected: boolean;
+    children: never[];
+}[];

package/dist/runtime/table/utils/filters/options.js

@@ -0,0 +1,112 @@
+import { getFilterLabelText, getFilterPathValues, isFilterValueSelected } from "./common.js";
+export function resolveFilterOptionEntries(options) {
+  if (options.definition.kind === "boolean") {
+    return createBooleanEntries({
+      definition: options.definition,
+      rows: options.rows,
+      selectedValues: options.selectedValues ?? [],
+      deriveCounts: options.deriveCounts ?? true,
+      facetCounts: options.facetCounts ?? [],
+      missingCountFallback: options.missingCountFallback
+    });
+  }
+  if (options.definition.kind !== "option") {
+    return [];
+  }
+  const sourceOptions = options.options ?? options.definition.source?.options ?? [];
+  const countByValue = new Map(
+    (options.facetCounts ?? []).map((entry) => [String(entry.value), entry.count])
+  );
+  return resolveOptionEntryTree({
+    entries: sourceOptions,
+    selectedValues: options.selectedValues ?? [],
+    getCount: (value) => countByValue.get(String(value)) ?? (options.deriveCounts === false || value == null ? options.missingCountFallback : countOptionMatches({
+      rows: options.rows,
+      key: options.definition.key,
+      candidate: value
+    }))
+  });
+}
+function createBooleanEntries(options) {
+  const trueCount = options.facetCounts.find((entry) => entry.value === true)?.count;
+  const falseCount = options.facetCounts.find((entry) => entry.value === false)?.count;
+  return [
+    {
+      id: "0:true",
+      label: "Yes",
+      value: true,
+      count: trueCount ?? (options.deriveCounts ? countOptionMatches({
+        rows: options.rows,
+        key: options.definition.key,
+        candidate: true
+      }) : options.missingCountFallback),
+      selected: isFilterValueSelected({
+        values: options.selectedValues,
+        candidate: true
+      }),
+      children: []
+    },
+    {
+      id: "1:false",
+      label: "No",
+      value: false,
+      count: falseCount ?? (options.deriveCounts ? countOptionMatches({
+        rows: options.rows,
+        key: options.definition.key,
+        candidate: false
+      }) : options.missingCountFallback),
+      selected: isFilterValueSelected({
+        values: options.selectedValues,
+        candidate: false
+      }),
+      children: []
+    }
+  ];
+}
+function resolveOptionEntryTree(options) {
+  return options.entries.map((entry, index) => {
+    const idPart = entry.value == null ? `group-${index}` : `${index}:${String(entry.value)}`;
+    const id = options.parentId ? `${options.parentId}/${idPart}` : idPart;
+    const children = resolveOptionEntryTree({
+      entries: entry.children ?? [],
+      selectedValues: options.selectedValues,
+      getCount: options.getCount,
+      parentId: id
+    });
+    const derivedCount = options.getCount(entry.value);
+    const selected = entry.value == null ? false : isFilterValueSelected({
+      values: options.selectedValues,
+      candidate: entry.value
+    });
+    return {
+      id,
+      label: getFilterLabelText({
+        label: entry.label
+      }),
+      value: entry.value,
+      icon: entry.icon,
+      count: entry.count ?? sumChildCounts(children) ?? derivedCount,
+      selected,
+      children
+    };
+  });
+}
+function sumChildCounts(entries) {
+  const counts = entries.map((entry) => entry.count).filter((count) => typeof count === "number");
+  if (!counts.length) return void 0;
+  return counts.reduce((total, count) => total + count, 0);
+}
+function countOptionMatches(options) {
+  return options.rows.reduce((count, row) => {
+    const values = getFilterPathValues({
+      source: row,
+      key: options.key
+    });
+    return count + (values.some(
+      (value) => isFilterValueSelected({
+        values: [value],
+        candidate: options.candidate
+      })
+    ) ? 1 : 0);
+  }, 0);
+}

package/dist/runtime/table/utils/filters/presentation.d.ts

@@ -0,0 +1,3 @@
+import type { TableFilterDisplayLocation, TableFilterDisplayLocationValue, TableUiFilterDefinition } from '../../types/index.js';
+export declare function resolveFilterDisplayLocation(value: TableFilterDisplayLocationValue | undefined): TableFilterDisplayLocation;
+export declare function resolveFilterDisplayOrder(definition: TableUiFilterDefinition): number;

package/dist/runtime/table/utils/filters/presentation.js

@@ -0,0 +1,18 @@
+import { getResponsiveValue } from "../../../shared/index.js";
+const FILTER_DISPLAY_LOCATIONS = [
+  "tag",
+  "panel",
+  "tag-dynamic"
+];
+export function resolveFilterDisplayLocation(value) {
+  if (!value) return "tag";
+  if (isFilterDisplayLocation(value)) return value;
+  const resolved = getResponsiveValue(value);
+  return isFilterDisplayLocation(resolved) ? resolved : "tag";
+}
+export function resolveFilterDisplayOrder(definition) {
+  return definition.display?.order ?? Number.MAX_SAFE_INTEGER;
+}
+function isFilterDisplayLocation(value) {
+  return typeof value === "string" && FILTER_DISPLAY_LOCATIONS.includes(value);
+}

package/dist/runtime/table/utils/filters/preview/date-preview.d.ts

@@ -0,0 +1,6 @@
+import type { TableDateFilterDefinition, TableQueryStateFilterRule } from '../../../types/index.js';
+import type { FilterPreviewResult } from './types.js';
+export declare function buildDateFilterPreview(options: {
+    definition: TableDateFilterDefinition;
+    rule: TableQueryStateFilterRule;
+}): FilterPreviewResult;

package/dist/runtime/table/utils/filters/preview/date-preview.js

@@ -0,0 +1,41 @@
+import { formatFilterDate, getDateRangeValue, toDateFilterValue, toMaybeDate } from "../common.js";
+import { resolveDateFilterUi } from "../ui.js";
+export function buildDateFilterPreview(options) {
+  const operator = resolveDateOperator(options.rule.operator);
+  const filterUi = resolveDateFilterUi(options.definition, operator);
+  const preview = operator === "between" ? filterUi.range.preview : filterUi.scalar.preview;
+  const range = getDateRangeValue({ value: options.rule.value });
+  if (range && (range.from || range.to)) {
+    const start = toMaybeDate({ value: range.from });
+    const end = toMaybeDate({ value: range.to });
+    const summary = preview.rangeFormatter ? preview.rangeFormatter({ from: start, to: end }) : [start, end].filter((value) => value instanceof Date).map((value) => formatFilterDate({ value })).join(" - ");
+    return {
+      active: true,
+      count: [start, end].filter(Boolean).length,
+      tags: [],
+      summary: prefixPreviewLabel(preview.label, summary)
+    };
+  }
+  const date = toDateFilterValue({
+    definition: options.definition,
+    value: options.rule.value
+  });
+  return {
+    active: Boolean(date),
+    count: date ? 1 : 0,
+    tags: [],
+    summary: date ? prefixPreviewLabel(
+      preview.label,
+      preview.formatter?.(date) ?? formatFilterDate({ value: date })
+    ) : ""
+  };
+}
+function resolveDateOperator(value) {
+  if (value === "isNot" || value === "before" || value === "after" || value === "between") {
+    return value;
+  }
+  return "is";
+}
+function prefixPreviewLabel(label, value) {
+  return label && value ? `${label}: ${value}` : value;
+}

package/dist/runtime/table/utils/filters/preview/index.d.ts

@@ -0,0 +1,8 @@
+import type { TableQueryStateFilterRule, TableUiFilterDefinition } from '../../../types/index.js';
+import type { FilterPreviewOptionEntry, FilterPreviewResult } from './types.js';
+export type { FilterPreviewResult, FilterPreviewOptionEntry };
+export declare function buildFilterPreview(options: {
+    definition: TableUiFilterDefinition;
+    rule?: TableQueryStateFilterRule;
+    optionEntries?: FilterPreviewOptionEntry[];
+}): FilterPreviewResult;

package/dist/runtime/table/utils/filters/preview/index.js

@@ -0,0 +1,38 @@
+import { buildDateFilterPreview } from "./date-preview.js";
+import { buildNumberFilterPreview } from "./number-preview.js";
+import { buildOptionFilterPreview } from "./option-preview.js";
+import { buildTextFilterPreview } from "./text-preview.js";
+const EMPTY_PREVIEW = {
+  active: false,
+  count: 0,
+  tags: [],
+  summary: ""
+};
+export function buildFilterPreview(options) {
+  if (!options.rule) {
+    return EMPTY_PREVIEW;
+  }
+  if (options.definition.kind === "option" || options.definition.kind === "boolean") {
+    return buildOptionFilterPreview({
+      definition: options.definition,
+      rule: options.rule,
+      optionEntries: options.optionEntries ?? []
+    });
+  }
+  if (options.definition.kind === "date") {
+    return buildDateFilterPreview({
+      definition: options.definition,
+      rule: options.rule
+    });
+  }
+  if (options.definition.kind === "number") {
+    return buildNumberFilterPreview({
+      definition: options.definition,
+      rule: options.rule
+    });
+  }
+  return buildTextFilterPreview({
+    definition: options.definition,
+    rule: options.rule
+  });
+}

package/dist/runtime/table/utils/filters/preview/number-preview.d.ts

@@ -0,0 +1,6 @@
+import type { TableNumberFilterDefinition, TableQueryStateFilterRule } from '../../../types/index.js';
+import type { FilterPreviewResult } from './types.js';
+export declare function buildNumberFilterPreview(options: {
+    definition: TableNumberFilterDefinition;
+    rule: TableQueryStateFilterRule;
+}): FilterPreviewResult;