@svgrid/enterprise 3.1.21 → 3.1.23

package/dist/relative-date-core.js

@@ -0,0 +1,85 @@
+/** The relative date operator ids, in menu order. */
+export const RELATIVE_DATE_OPERATOR_IDS = ['today', 'beforeToday', 'afterToday', 'next7Days', 'last7Days'];
+const DAY_MS = 86400000;
+/** Whether `op` is one of the relative date operators. */
+export function isRelativeDateOperator(op) {
+    return RELATIVE_DATE_OPERATOR_IDS.includes(op);
+}
+/**
+ * A value as a count of local calendar days, or NaN. A bare 'YYYY-MM-DD' is
+ * that day in local time; `new Date()` would read it as UTC midnight, the day
+ * before anywhere west of Greenwich.
+ */
+function localDayNumber(value) {
+    let d;
+    if (value instanceof Date)
+        d = value;
+    else if (typeof value === 'number')
+        d = new Date(value);
+    else if (typeof value === 'string' && value.trim()) {
+        const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value.trim());
+        d = m ? new Date(Number(m[1]), Number(m[2]) - 1, Number(m[3])) : new Date(value);
+    }
+    else
+        return NaN;
+    if (Number.isNaN(d.getTime()))
+        return NaN;
+    return Math.round(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()) / DAY_MS);
+}
+/** The inclusive range of local day numbers an operator keeps. */
+function dayRange(op, now) {
+    const t = localDayNumber(now);
+    switch (op) {
+        case 'today':
+            return [t, t];
+        case 'beforeToday':
+            return [-Infinity, t - 1];
+        case 'afterToday':
+            return [t + 1, Infinity];
+        case 'next7Days':
+            return [t, t + 7];
+        case 'last7Days':
+            return [t - 7, t];
+    }
+}
+/** Local 'YYYY-MM-DD' for a day number from `localDayNumber`. */
+function isoFromDayNumber(day) {
+    return new Date(day * DAY_MS).toISOString().slice(0, 10);
+}
+/**
+ * The test for one relative date operator. "Today" is read once, here, so a
+ * page left open past midnight keeps the old day until the filter changes.
+ * A blank or unparseable cell never matches.
+ */
+export function compileRelativeDateFilter(op, now = new Date()) {
+    const [lo, hi] = dayRange(op, now);
+    return (cellValue) => {
+        const day = localDayNumber(cellValue);
+        return day >= lo && day <= hi;
+    };
+}
+/**
+ * A relative date filter as the absolute one it means today, for a backend
+ * with no "today" of its own: `beforeToday` becomes `lessThan` today's date,
+ * `next7Days` becomes `between` today and a week out, and so on, with dates as
+ * local 'YYYY-MM-DD'. Any other filter is returned as it is.
+ *
+ * A server data source gets this applied for it. Under `externalFilter` the
+ * `onFiltersChange` payload keeps the relative operator, so a saved view still
+ * means "overdue" tomorrow; call this when you build the query.
+ */
+export function resolveRelativeDateFilter(filter, now = new Date()) {
+    if (!isRelativeDateOperator(filter.operator))
+        return filter;
+    const op = filter.operator;
+    const [lo, hi] = dayRange(op, now);
+    const out = { ...filter };
+    delete out.valueTo;
+    if (op === 'beforeToday')
+        Object.assign(out, { operator: 'lessThan', value: isoFromDayNumber(hi + 1) });
+    else if (op === 'afterToday')
+        Object.assign(out, { operator: 'greaterThan', value: isoFromDayNumber(lo - 1) });
+    else
+        Object.assign(out, { operator: 'between', value: isoFromDayNumber(lo), valueTo: isoFromDayNumber(hi) });
+    return out;
+}

package/dist/relative-dates.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Relative date filters - five date operators measured from today, in whole
+ * local days: Today, Before today (overdue), After today, Next 7 days and
+ * Last 7 days. They take no value, so picking one in a date column's filter
+ * menu filters at once. They plug into the grid's `filterOperators` seam, so a
+ * grid without this module carries none of the code.
+ *
+ * Like the rest of Enterprise it runs without a license key during the
+ * evaluation; the grid shows the watermark and a one-time console notice.
+ *
+ * ```ts
+ * import { enableRelativeDateFilters } from '@svgrid/enterprise'
+ * enableRelativeDateFilters()
+ * // then: a column with cellDataType 'date' or 'dateString' offers them
+ * api.setFilter('due', { operator: 'beforeToday' })
+ * ```
+ */
+import { type GridFilterOperator } from '@svgrid/grid';
+import { type RelativeDateOperator } from './relative-date-core.js';
+export { RELATIVE_DATE_OPERATOR_IDS, isRelativeDateOperator, compileRelativeDateFilter, resolveRelativeDateFilter, type RelativeDateOperator, } from './relative-date-core.js';
+/** The operators as the grid's `filterOperators` seam takes them. */
+export declare const relativeDateOperators: Record<RelativeDateOperator, GridFilterOperator>;
+/**
+ * Add the relative date operators to every grid's date filters. Idempotent:
+ * call it once at app start or from each component that uses them. Also
+ * invoked by {@link installEnterprise}.
+ */
+export declare function enableRelativeDateFilters(): void;

package/dist/relative-dates.js

@@ -0,0 +1,61 @@
+/**
+ * Relative date filters - five date operators measured from today, in whole
+ * local days: Today, Before today (overdue), After today, Next 7 days and
+ * Last 7 days. They take no value, so picking one in a date column's filter
+ * menu filters at once. They plug into the grid's `filterOperators` seam, so a
+ * grid without this module carries none of the code.
+ *
+ * Like the rest of Enterprise it runs without a license key during the
+ * evaluation; the grid shows the watermark and a one-time console notice.
+ *
+ * ```ts
+ * import { enableRelativeDateFilters } from '@svgrid/enterprise'
+ * enableRelativeDateFilters()
+ * // then: a column with cellDataType 'date' or 'dateString' offers them
+ * api.setFilter('due', { operator: 'beforeToday' })
+ * ```
+ */
+import { getGridExtension, registerGridExtension } from '@svgrid/grid';
+import { hasValidLicense } from './license.js';
+import { emitUnlicensedNudge } from './watermark.js';
+import { compileRelativeDateFilter, resolveRelativeDateFilter, } from './relative-date-core.js';
+export { RELATIVE_DATE_OPERATOR_IDS, isRelativeDateOperator, compileRelativeDateFilter, resolveRelativeDateFilter, } from './relative-date-core.js';
+const LABELS = {
+    today: 'Today',
+    beforeToday: 'Before today',
+    afterToday: 'After today',
+    next7Days: 'Next 7 days',
+    last7Days: 'Last 7 days',
+};
+function operator(op) {
+    return {
+        label: LABELS[op],
+        types: ['date'],
+        valueless: true,
+        compile: () => compileRelativeDateFilter(op),
+        toServer: (filter) => resolveRelativeDateFilter(filter),
+    };
+}
+/** The operators as the grid's `filterOperators` seam takes them. */
+export const relativeDateOperators = {
+    today: operator('today'),
+    beforeToday: operator('beforeToday'),
+    afterToday: operator('afterToday'),
+    next7Days: operator('next7Days'),
+    last7Days: operator('last7Days'),
+};
+let enabled = false;
+/**
+ * Add the relative date operators to every grid's date filters. Idempotent:
+ * call it once at app start or from each component that uses them. Also
+ * invoked by {@link installEnterprise}.
+ */
+export function enableRelativeDateFilters() {
+    if (enabled)
+        return;
+    enabled = true;
+    // Another module may have added operators of its own; keep them.
+    registerGridExtension({ filterOperators: { ...getGridExtension()?.filterOperators, ...relativeDateOperators } });
+    if (!hasValidLicense())
+        emitUnlicensedNudge();
+}

package/dist/review/GhostCell.svelte

@@ -0,0 +1,60 @@
+<!--
+  A cell with a pending proposal: the proposed value, then what the cell
+  holds now, struck through. `own` is what the column's own `cell` returned (a
+  component, a snippet, text, or nothing for a plain column).
+-->
+<script lang="ts">
+  import type { Component, Snippet } from 'svelte'
+
+  let { own, before, beforeText, after, empty, title }: {
+    own: unknown
+    before: unknown
+    beforeText: string
+    after: string
+    /** The text for a blank proposed value, in the review's wording. */
+    empty: string
+    /** "{source} proposes {value} - reason", built by the wrapper. */
+    title: string
+  } = $props()
+
+  // The grid's render configs (`renderComponent` / `renderSnippet`) are read by
+  // shape: the classes are not part of the public surface.
+  type ComponentConfig = { component: Component<any>; props?: Record<string, unknown> }
+  type SnippetConfig = { snippet: Snippet<[unknown]>; params?: unknown }
+  const isObj = (v: unknown): v is Record<string, unknown> => v !== null && typeof v === 'object'
+  const ownComponent = $derived(isObj(own) && typeof own.component === 'function' ? (own as ComponentConfig) : null)
+  const ownSnippet = $derived(isObj(own) && typeof own.snippet === 'function' ? (own as SnippetConfig) : null)
+  const ownText = $derived(typeof own === 'string' || typeof own === 'number' ? String(own) : beforeText)
+</script>
+
+<span class="sv-review-ghost" {title}>
+  <span class="sv-review-ghost-after">{after || empty}</span>
+  {#if before != null && before !== ''}
+    <s class="sv-review-ghost-before">
+      {#if ownComponent}<ownComponent.component {...ownComponent.props ?? {}} />{:else if ownSnippet}{@render ownSnippet.snippet(ownSnippet.params)}{:else}{ownText}{/if}
+    </s>
+  {/if}
+</span>
+
+<style>
+  /* Inline text beside the grid's own icon: a block or flex box here would drop
+     to a line of its own. The proposed value comes first and is plain text, so
+     the cell's ellipsis cuts its end. The struck value is one box, at most half
+     the cell: when it does not fit, the ellipsis takes it whole instead of
+     leaving a cut-off fragment, and the cell's title still names it. */
+  .sv-review-ghost-before {
+    display: inline-block;
+    max-width: 50%;
+    margin-left: 6px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+    vertical-align: bottom;
+    color: var(--sg-muted, #6b7280);
+    text-decoration-thickness: 1px;
+  }
+  .sv-review-ghost-after {
+    color: var(--sg-fg, inherit);
+    font-weight: 600;
+  }
+</style>

package/dist/review/GhostCell.svelte.d.ts

@@ -0,0 +1,14 @@
+import type { Component } from 'svelte';
+type $$ComponentProps = {
+    own: unknown;
+    before: unknown;
+    beforeText: string;
+    after: string;
+    /** The text for a blank proposed value, in the review's wording. */
+    empty: string;
+    /** "{source} proposes {value} - reason", built by the wrapper. */
+    title: string;
+};
+declare const GhostCell: Component<$$ComponentProps, {}, "">;
+type GhostCell = ReturnType<typeof GhostCell>;
+export default GhostCell;

package/dist/review/RichCellMark.svelte

@@ -0,0 +1,72 @@
+<!--
+  The proposed value after a rich cell (a select, a rating, a person): the
+  cell draws as it always does, and "-> Closed" follows it. The text is the
+  column's own formatter's (a person's name, not their id), else the plain
+  formatted value.
+-->
+<script lang="ts">
+  import { formatValueForExport } from '@svgrid/grid'
+  import { cellProposalFor } from './card-marks.svelte'
+  import { showValue } from './cluster'
+  import { fill } from './messages'
+
+  let { ctrl, row, column }: { ctrl: any; row: any; column: any } = $props()
+
+  /** A value's label from a static options list ({ value, label } or plain values); null when there is none. */
+  function optionLabels(options: unknown): ((v: unknown) => string | null) | null {
+    if (!Array.isArray(options)) return null
+    const byValue = new Map<string, string>()
+    for (const o of options) {
+      if (o && typeof o === 'object' && 'value' in o) byValue.set(String((o as { value: unknown }).value), String((o as { label?: unknown }).label ?? (o as { value: unknown }).value))
+      else byValue.set(String(o), String(o))
+    }
+    return (v) => byValue.get(String(v)) ?? null
+  }
+
+  const proposal = $derived(cellProposalFor(ctrl?.props?.getRowId, row?.original, String(row?.id), column?.columnDef?.field))
+  const text = $derived.by(() => {
+    if (!proposal) return ''
+    const def = column?.columnDef ?? {}
+    const value = proposal.after
+    if (value == null || value === '') return proposal.empty
+    if (typeof def.formatter === 'function') {
+      try {
+        return String(def.formatter({ value, row, column, table: ctrl?.grid }) ?? '')
+      } catch {
+        // A formatter that needs more than a value: fall back to the value.
+      }
+    }
+    // A list or chips column shows option labels, not stored values.
+    const labelOf = optionLabels(def.editorOptions)
+    const one = (v: unknown) => labelOf?.(v) ?? (Array.isArray(value) ? showValue(v).replace(/^"|"$/g, '') : formatValueForExport(v, def.format))
+    return Array.isArray(value) ? value.map(one).join(', ') : one(value)
+  })
+</script>
+
+{#if proposal}
+  <span
+    class="sv-review-cellmark"
+    title="{fill(proposal.proposes, { source: proposal.source, value: text })}{proposal.reason ? ` - ${proposal.reason}` : ''}"
+  ><span aria-hidden="true">→</span> {text}</span>
+{/if}
+
+<style>
+  .sv-review-cellmark {
+    display: inline-flex;
+    align-items: center;
+    gap: 3px;
+    margin-left: 6px;
+    flex: none;
+    max-width: 60%;
+    overflow: hidden;
+    white-space: nowrap;
+    text-overflow: ellipsis;
+    font-size: 0.92em;
+    font-weight: 600;
+    color: var(--sg-fg, #111827);
+  }
+  .sv-review-cellmark > span {
+    color: var(--sg-muted, #6b7280);
+    font-weight: 400;
+  }
+</style>

package/dist/review/RichCellMark.svelte.d.ts

@@ -0,0 +1,8 @@
+type $$ComponentProps = {
+    ctrl: any;
+    row: any;
+    column: any;
+};
+declare const RichCellMark: import("svelte").Component<$$ComponentProps, {}, "">;
+type RichCellMark = ReturnType<typeof RichCellMark>;
+export default RichCellMark;