@olenbetong/appframe-core 2.15.2 → 2.16.0

package/es/filter/columnValues.test.d.ts

@@ -0,0 +1 @@
+export {};

package/es/filter/columnValues.test.js

@@ -0,0 +1,119 @@
+import { describe, expect, test } from "vitest";
+import { describeFilter } from "./describeFilter.js";
+import { getColumnsForField, getDynamicValuesForField, getOperatorArity, getOperatorsForField, supportsColumnValue, } from "./operators.js";
+import { changeOperator, isCompleteExpression, needsFilterString } from "./tree.js";
+const fields = [
+    { name: "Date", caption: "Dato", type: "date" },
+    { name: "DeliveryDate", caption: "Leveringsdato", type: "datetime" },
+    { name: "Amount", caption: "Beløp", type: "number" },
+    { name: "Quantity", type: "number" },
+    { name: "Hidden", type: "number", excludeFromFilter: true },
+    { name: "Name", type: "string" },
+    { name: "Active", type: "boolean" },
+    { name: "Archived", type: "boolean" },
+];
+function expression(partial) {
+    return {
+        type: "expression",
+        column: "DeliveryDate",
+        operator: "greaterthan",
+        value: "",
+        valueType: "datetime",
+        ...partial,
+    };
+}
+function group(...items) {
+    return { type: "group", mode: "and", items };
+}
+describe("getColumnsForField", () => {
+    test("offers the other fields of the same type, dates and datetimes together", () => {
+        expect(getColumnsForField(fields[1], fields).map((field) => field.name)).toEqual(["Date"]);
+        expect(getColumnsForField(fields[2], fields).map((field) => field.name)).toEqual(["Quantity"]);
+    });
+    test("offers nothing for booleans", () => {
+        expect(getColumnsForField(fields[6], fields)).toEqual([]);
+    });
+});
+describe("supportsColumnValue", () => {
+    test("allows comparisons and ranges, not text checks or lists", () => {
+        expect(supportsColumnValue("greaterthan")).toBe(true);
+        expect(supportsColumnValue("between")).toBe(true);
+        expect(supportsColumnValue("contains")).toBe(false);
+        expect(supportsColumnValue("inlist")).toBe(false);
+    });
+});
+describe("getDynamicValuesForField", () => {
+    test("includes the dates only the Windows editor had", () => {
+        expect(getDynamicValuesForField({ type: "date" })).toEqual(expect.arrayContaining(["Now", "DayAfterTomorrow", "TwoWeeksAway"]));
+    });
+});
+describe("needsFilterString", () => {
+    test("is false for values the framework reads", () => {
+        expect(needsFilterString(group(expression({ value: "Today", valueType: "special" })))).toBe(false);
+        expect(needsFilterString(group(expression({ operator: "between", value: ["2026-01-01", "2026-02-01"] })))).toBe(false);
+    });
+    test("is true for a column value", () => {
+        expect(needsFilterString(group(expression({ value: "Date", valueType: "column" })))).toBe(true);
+    });
+    test("is true for a date only the Windows editor had", () => {
+        expect(needsFilterString(group(expression({ value: "TwoWeeksAway", valueType: "special" })))).toBe(true);
+    });
+    test("is true for a range with an end that is not a plain value", () => {
+        let range = expression({
+            operator: "between",
+            value: [{ valueType: "special", value: "Tomorrow" }, "2026-02-01"],
+        });
+        expect(needsFilterString({ type: "group", mode: "or", items: [group(range)] })).toBe(true);
+    });
+});
+describe("isCompleteExpression", () => {
+    test("needs a value at both ends of a range", () => {
+        let complete = expression({ operator: "between", value: [{ valueType: "column", value: "Date" }, "2026-02-01"] });
+        let missing = expression({ operator: "between", value: [{ valueType: "column", value: "" }, "2026-02-01"] });
+        expect(isCompleteExpression(complete)).toBe(true);
+        expect(isCompleteExpression(missing)).toBe(false);
+    });
+});
+describe("changeOperator", () => {
+    test("keeps a column across comparisons", () => {
+        let changed = changeOperator(expression({ value: "Date", valueType: "column" }), "lessthan", fields[1]);
+        expect(changed).toMatchObject({ value: "Date", valueType: "column" });
+    });
+    test("drops a column for an operator that cannot use one", () => {
+        let changed = changeOperator(expression({ column: "Name", value: "Other", valueType: "column" }), "contains", fields[5]);
+        expect(changed).toMatchObject({ value: "", valueType: "string" });
+    });
+});
+describe("describeFilter", () => {
+    test("names the compared column by its caption", () => {
+        expect(describeFilter(group(expression({ value: "Date", valueType: "column" })), { fields })).toBe("[Leveringsdato] After [Dato]");
+    });
+    test("describes each end of a range", () => {
+        let range = expression({
+            operator: "between",
+            value: [
+                { valueType: "special", value: "Tomorrow" },
+                { valueType: "special", value: "TwoWeeksAway" },
+            ],
+        });
+        expect(describeFilter(group(range), { fields })).toBe("[Leveringsdato] Between Tomorrow - Two weeks away");
+    });
+});
+describe("period operators", () => {
+    test("are offered for dates and take no value", () => {
+        let operators = getOperatorsForField({ type: "datetime" });
+        expect(operators).toContain("islastweek");
+        expect(operators).toContain("ispriorthisyear");
+        expect(getOperatorsForField({ type: "number" })).not.toContain("islastweek");
+        expect(getOperatorArity("islastweek")).toBe("none");
+    });
+    test("need a filter string", () => {
+        let period = expression({ operator: "islastweek", value: null, valueType: "null" });
+        expect(isCompleteExpression(period)).toBe(true);
+        expect(needsFilterString(group(period))).toBe(true);
+    });
+    test("are described without a value", () => {
+        let period = expression({ operator: "islastweek", value: null, valueType: "null" });
+        expect(describeFilter(group(period), { fields })).toBe("[Leveringsdato] Is last week");
+    });
+});

package/es/filter/describeFilter.js

@@ -1,5 +1,5 @@
 import { getDynamicValueLabel, getOperatorArity, getOperatorLabel, normalizeOperator } from "./operators.js";
-import { isExpression } from "./tree.js";
+import { isExpression, isRangeEnd } from "./tree.js";
 /**
  * Builds a human-readable description of a filter, without contacting the
  * server. Use this for read-only summaries; the authoritative filter string is
@@ -34,20 +34,22 @@ function describeExpression(expression, fields) {
     let arity = getOperatorArity(operator);
     if (arity === "none")
         return `[${caption}] ${label}`;
-    return `[${caption}] ${label} ${formatValue(expression, arity)}`;
+    return `[${caption}] ${label} ${formatValue(expression, arity, fields)}`;
 }
-function formatValue(expression, arity) {
+function formatValue(expression, arity, fields) {
     let { value, valueType } = expression;
-    if (valueType === "special" && typeof value === "string") {
-        return getDynamicValueLabel(value);
-    }
     if (Array.isArray(value)) {
-        let formatted = value.map((item) => formatScalar(item, valueType));
+        let formatted = value.map((item) => isRangeEnd(item) ? formatScalar(item.value, item.valueType, fields) : formatScalar(item, valueType, fields));
         return arity === "pair" ? formatted.join(" - ") : `(${formatted.join(", ")})`;
     }
-    return formatScalar(value, valueType);
+    return formatScalar(value, valueType, fields);
 }
-function formatScalar(value, valueType) {
+function formatScalar(value, valueType, fields) {
+    if (valueType === "special" && typeof value === "string")
+        return getDynamicValueLabel(value);
+    if (valueType === "column" && typeof value === "string") {
+        return `[${fields.get(value.toLowerCase())?.caption ?? value}]`;
+    }
     if (value === null || value === undefined)
         return "";
     if (value instanceof Date)

package/es/filter/index.d.ts

@@ -1,8 +1,8 @@
 export { type ConvertRequest, convertFilter, type FilterConversionResult } from "./convertFilter.js";
 export { describeFilter, type DescribeFilterOptions } from "./describeFilter.js";
 export { toFieldMetadata, toFieldMetadataList, toFilterFieldType, type ViewFieldRecord } from "./fields.js";
-export { getDefaultOperator, getDynamicValueLabel, getDynamicValuesForField, getOperatorArity, getOperatorLabel, getOperatorsForField, getValueType, normalizeOperator, type OperatorArity, RELATIVE_DATE_VALUES, } from "./operators.js";
+export { getColumnsForField, getDefaultOperator, getDynamicValueLabel, getDynamicValuesForField, getOperatorArity, getOperatorLabel, getOperatorsForField, getValueType, normalizeOperator, type OperatorArity, PERIOD_OPERATORS, RELATIVE_DATE_VALUES, supportsColumnValue, } from "./operators.js";
 export { coerceToStandardLayout, isStandardLayout } from "./standardLayout.js";
 export { canDeleteSavedFilter, canEditSavedFilter, canRenameSavedFilter, canSetCrossDomain, canShareSavedFilter, findSavedFilter, NO_FILTER_ID, partitionSavedFilters, type SavedFilter, type SavedFilterRecord, toSavedFilter, toSavedFilters, } from "./savedFilters.js";
-export { addGroupAtPath, changeOperator, countExpressions, createEmptyFilter, createEmptyGroup, createExpression, type FilterNode, type FilterPath, getNodeAtPath, insertNodeAtPath, isCompleteExpression, isEmptyFilter, isExpression, isGroup, pruneFilter, removeNodeAtPath, setGroupMode, toFilterTree, unwrapSingleAndGroup, updateNodeAtPath, } from "./tree.js";
-export type { DynamicValue, FieldMetadata, FilterAccessLevel, FilterExpression, FilterFieldType, FilterGroup, FilterOperator, FilterTree, FilterValueType, } from "./types.js";
+export { addGroupAtPath, changeOperator, countExpressions, createEmptyFilter, createEmptyGroup, createExpression, type FilterNode, type FilterPath, getNodeAtPath, insertNodeAtPath, isCompleteExpression, isEmptyFilter, isExpression, isGroup, isRangeEnd, needsFilterString, pruneFilter, removeNodeAtPath, setGroupMode, toFilterTree, unwrapSingleAndGroup, updateNodeAtPath, } from "./tree.js";
+export type { DynamicValue, FieldMetadata, FilterAccessLevel, FilterExpression, FilterFieldType, FilterGroup, FilterOperator, FilterRangeEnd, FilterTree, FilterValueType, } from "./types.js";

package/es/filter/index.js

@@ -1,7 +1,7 @@
 export { convertFilter } from "./convertFilter.js";
 export { describeFilter } from "./describeFilter.js";
 export { toFieldMetadata, toFieldMetadataList, toFilterFieldType } from "./fields.js";
-export { getDefaultOperator, getDynamicValueLabel, getDynamicValuesForField, getOperatorArity, getOperatorLabel, getOperatorsForField, getValueType, normalizeOperator, RELATIVE_DATE_VALUES, } from "./operators.js";
+export { getColumnsForField, getDefaultOperator, getDynamicValueLabel, getDynamicValuesForField, getOperatorArity, getOperatorLabel, getOperatorsForField, getValueType, normalizeOperator, PERIOD_OPERATORS, RELATIVE_DATE_VALUES, supportsColumnValue, } from "./operators.js";
 export { coerceToStandardLayout, isStandardLayout } from "./standardLayout.js";
 export { canDeleteSavedFilter, canEditSavedFilter, canRenameSavedFilter, canSetCrossDomain, canShareSavedFilter, findSavedFilter, NO_FILTER_ID, partitionSavedFilters, toSavedFilter, toSavedFilters, } from "./savedFilters.js";
-export { addGroupAtPath, changeOperator, countExpressions, createEmptyFilter, createEmptyGroup, createExpression, getNodeAtPath, insertNodeAtPath, isCompleteExpression, isEmptyFilter, isExpression, isGroup, pruneFilter, removeNodeAtPath, setGroupMode, toFilterTree, unwrapSingleAndGroup, updateNodeAtPath, } from "./tree.js";
+export { addGroupAtPath, changeOperator, countExpressions, createEmptyFilter, createEmptyGroup, createExpression, getNodeAtPath, insertNodeAtPath, isCompleteExpression, isEmptyFilter, isExpression, isGroup, isRangeEnd, needsFilterString, pruneFilter, removeNodeAtPath, setGroupMode, toFilterTree, unwrapSingleAndGroup, updateNodeAtPath, } from "./tree.js";

package/es/filter/operators.d.ts

@@ -1,4 +1,10 @@
 import type { DynamicValue, FieldMetadata, FilterFieldType, FilterOperator, FilterValueType } from "./types.js";
+/**
+ * Whole-period checks for dates, such as "Is last week", in the order of the
+ * Windows filter editor. They take no value. The framework has no operator for
+ * them, so a filter using one is sent as a filter string (`needsFilterString`).
+ */
+export declare const PERIOD_OPERATORS: FilterOperator[];
 /** How many values an operator needs. */
 export type OperatorArity = "none" | "single" | "pair" | "list";
 export declare function getOperatorArity(operator: FilterOperator): OperatorArity;
@@ -30,6 +36,14 @@ export declare function getDynamicValueLabel(value: DynamicValue): string;
  * user name.
  */
 export declare function getDynamicValuesForField(field: Pick<FieldMetadata, "type">): DynamicValue[];
+/** Whether an operator can take another column as its value. */
+export declare function supportsColumnValue(operator: FilterOperator): boolean;
+/**
+ * The columns a field can be compared with: the other fields of the same type,
+ * as in the Windows filter editor. Booleans have only true and false checks,
+ * so they get none.
+ */
+export declare function getColumnsForField(field: Pick<FieldMetadata, "name" | "type">, fields: FieldMetadata[]): FieldMetadata[];
 /**
  * Normalizes an operator string coming from the server or from another filter
  * producer (`AfGrid` emits PascalCase names) to the canonical lower-case form.

package/es/filter/operators.js

@@ -5,12 +5,32 @@ import { getLocalizedString } from "../getLocalizedString.js";
  * `eOperators.ParameterLessChecks` plus the blank checks.
  */
 const PARAMETERLESS_OPERATORS = ["isnull", "isnotnull", "istrue", "isfalse", "isblank", "isnotblank"];
+/**
+ * Whole-period checks for dates, such as "Is last week", in the order of the
+ * Windows filter editor. They take no value. The framework has no operator for
+ * them, so a filter using one is sent as a filter string (`needsFilterString`).
+ */
+export const PERIOD_OPERATORS = [
+    "isbeyondthisyear",
+    "islaterthisyear",
+    "islaterthismonth",
+    "isnextweek",
+    "islaterthisweek",
+    "istomorrow",
+    "istoday",
+    "isyesterday",
+    "isearlierthisweek",
+    "islastweek",
+    "isearlierthismonth",
+    "isearlierthisyear",
+    "ispriorthisyear",
+];
 /** Operators whose value is a two element `[from, to]` array. */
 const PAIR_OPERATORS = ["between", "notbetween", "datebetween", "datenotbetween"];
 /** Operators whose value is an array of values. */
 const LIST_OPERATORS = ["inlist", "notinlist"];
 export function getOperatorArity(operator) {
-    if (PARAMETERLESS_OPERATORS.includes(operator))
+    if (PARAMETERLESS_OPERATORS.includes(operator) || PERIOD_OPERATORS.includes(operator))
         return "none";
     if (PAIR_OPERATORS.includes(operator))
         return "pair";
@@ -57,6 +77,19 @@ const OPERATOR_LABELS = {
     datelessthanorequal: "Up to",
     datebetween: "Between",
     datenotbetween: "Not between",
+    isbeyondthisyear: "Is beyond this year",
+    islaterthisyear: "Is later this year",
+    islaterthismonth: "Is later this month",
+    isnextweek: "Is next week",
+    islaterthisweek: "Is later this week",
+    istomorrow: "Is tomorrow",
+    istoday: "Is today",
+    isyesterday: "Is yesterday",
+    isearlierthisweek: "Is earlier this week",
+    islastweek: "Is last week",
+    isearlierthismonth: "Is earlier this month",
+    isearlierthisyear: "Is earlier this year",
+    ispriorthisyear: "Is prior to this year",
 };
 /** Comparison operator labels used for date and time fields. */
 const DATE_OPERATOR_LABELS = {
@@ -93,8 +126,8 @@ const STRING_CHECKS = [
  * presents them.
  */
 const OPERATORS_BY_TYPE = {
-    date: [...EQUALITY, ...LIST_CHECKS, ...RANGE, ...COMPARISONS],
-    datetime: [...EQUALITY, ...LIST_CHECKS, ...RANGE, ...COMPARISONS],
+    date: [...EQUALITY, ...LIST_CHECKS, ...RANGE, ...COMPARISONS, ...PERIOD_OPERATORS],
+    datetime: [...EQUALITY, ...LIST_CHECKS, ...RANGE, ...COMPARISONS, ...PERIOD_OPERATORS],
     number: [...EQUALITY, ...LIST_CHECKS, ...RANGE, ...COMPARISONS],
     boolean: ["istrue", "isfalse"],
     string: [...EQUALITY, ...STRING_CHECKS, ...LIST_CHECKS, ...RANGE, ...COMPARISONS],
@@ -157,7 +190,10 @@ export function getValueType(field, operator) {
 export const RELATIVE_DATE_VALUES = [
     "Yesterday",
     "Today",
+    "Now",
     "Tomorrow",
+    "DayAfterTomorrow",
+    "TwoWeeksAway",
     "ThisWeek",
     "ThisMonth",
     "ThisYear",
@@ -172,7 +208,10 @@ const DYNAMIC_VALUE_LABELS = {
     CurrentUser: "Current user",
     Yesterday: "Yesterday",
     Today: "Today",
+    Now: "Now",
     Tomorrow: "Tomorrow",
+    DayAfterTomorrow: "Day after tomorrow",
+    TwoWeeksAway: "Two weeks away",
     ThisWeek: "This week",
     ThisMonth: "This month",
     ThisYear: "This year",
@@ -210,6 +249,27 @@ export function getDynamicValuesForField(field) {
         return ["CurrentUser"];
     return [];
 }
+/** Operators that can compare a field with another column. */
+const COLUMN_OPERATORS = [...EQUALITY, ...RANGE, ...COMPARISONS];
+/** Whether an operator can take another column as its value. */
+export function supportsColumnValue(operator) {
+    return COLUMN_OPERATORS.includes(operator);
+}
+/** Dates and datetimes compare with each other; other types only with their own. */
+function getComparableType(type) {
+    return type === "datetime" ? "date" : type;
+}
+/**
+ * The columns a field can be compared with: the other fields of the same type,
+ * as in the Windows filter editor. Booleans have only true and false checks,
+ * so they get none.
+ */
+export function getColumnsForField(field, fields) {
+    if (field.type === "boolean")
+        return [];
+    let type = getComparableType(field.type);
+    return fields.filter((other) => other.name !== field.name && !other.excludeFromFilter && getComparableType(other.type) === type);
+}
 /**
  * Aliases for names `eOperators.ToString()` can produce that are not operators
  * in their own right. `Not` is the bare negation flag (i.e. "not equal to"),

package/es/filter/tree.d.ts

@@ -1,4 +1,4 @@
-import type { FieldMetadata, FilterExpression, FilterGroup, FilterOperator, FilterTree } from "./types.js";
+import type { FieldMetadata, FilterExpression, FilterGroup, FilterOperator, FilterRangeEnd, FilterTree } from "./types.js";
 /**
  * Path to a node in a filter tree, as a list of item indexes from the root
  * group. The root itself is the empty path.
@@ -49,6 +49,15 @@ export declare function pruneFilter(filter: FilterNode | null | undefined): Filt
  * True when an expression has everything it needs to be sent to the server.
  */
 export declare function isCompleteExpression(item: FilterNode): boolean;
+/** Whether a range value end is a `FilterRangeEnd` rather than a plain value. */
+export declare function isRangeEnd(value: unknown): value is FilterRangeEnd;
+/**
+ * True when the filter holds something the framework's data API cannot read
+ * from a filter object: another column, a range end that is not a plain value,
+ * one of the dates only the Windows editor offers, or a whole-period check. Such a filter must be
+ * converted with `convertFilter` and sent as a filter string.
+ */
+export declare function needsFilterString(filter: FilterNode | null | undefined): boolean;
 /**
  * Creates an expression for a field, using the field's default operator and an
  * empty value of the right shape.

package/es/filter/tree.js

@@ -1,4 +1,4 @@
-import { getDefaultOperator, getOperatorArity, getValueType, normalizeOperator } from "./operators.js";
+import { getDefaultOperator, getOperatorArity, getValueType, normalizeOperator, PERIOD_OPERATORS, supportsColumnValue, } from "./operators.js";
 /**
  * Creates the default empty filter: a single `and` group with no conditions.
  */
@@ -86,13 +86,46 @@ export function isCompleteExpression(item) {
     if (item.value === null || item.value === undefined || item.value === "")
         return false;
     if (arity === "pair") {
-        return Array.isArray(item.value) && item.value.length === 2 && item.value.every((v) => v !== "" && v != null);
+        return (Array.isArray(item.value) &&
+            item.value.length === 2 &&
+            item.value.every((v) => {
+                let end = isRangeEnd(v) ? v.value : v;
+                return end !== "" && end != null;
+            }));
     }
     if (arity === "list") {
         return Array.isArray(item.value) && item.value.length > 0;
     }
     return true;
 }
+/** Whether a range value end is a `FilterRangeEnd` rather than a plain value. */
+export function isRangeEnd(value) {
+    return typeof value === "object" && value !== null && !(value instanceof Date) && "valueType" in value;
+}
+/** Dynamic values the framework has no `eDynamicValue` member for. */
+const DYNAMIC_VALUES_WITHOUT_FRAMEWORK_SUPPORT = new Set(["Now", "DayAfterTomorrow", "TwoWeeksAway"]);
+function needsConversion(valueType, value) {
+    if (valueType === "column")
+        return true;
+    return valueType === "special" && typeof value === "string" && DYNAMIC_VALUES_WITHOUT_FRAMEWORK_SUPPORT.has(value);
+}
+/**
+ * True when the filter holds something the framework's data API cannot read
+ * from a filter object: another column, a range end that is not a plain value,
+ * one of the dates only the Windows editor offers, or a whole-period check. Such a filter must be
+ * converted with `convertFilter` and sent as a filter string.
+ */
+export function needsFilterString(filter) {
+    if (!filter)
+        return false;
+    if (isGroup(filter))
+        return filter.items.some(needsFilterString);
+    if (PERIOD_OPERATORS.includes(normalizeOperator(filter.operator)))
+        return true;
+    if (needsConversion(filter.valueType, filter.value))
+        return true;
+    return Array.isArray(filter.value) && filter.value.some((item) => isRangeEnd(item));
+}
 /**
  * Creates an expression for a field, using the field's default operator and an
  * empty value of the right shape.
@@ -127,11 +160,16 @@ export function changeOperator(expression, operator, field) {
     let previousArity = getOperatorArity(normalizeOperator(expression.operator));
     let arity = getOperatorArity(operator);
     let value = expression.value;
-    if (arity !== previousArity) {
+    // A column only makes sense for comparisons, not for text checks such as
+    // "contains".
+    let holdsColumn = expression.valueType === "column" ||
+        (Array.isArray(value) && value.some((item) => isRangeEnd(item) && item.valueType === "column"));
+    if (arity !== previousArity || (holdsColumn && !supportsColumnValue(operator))) {
         value = createEmptyValue(operator);
     }
-    // A dynamic value stays valid across operators of the same arity.
-    let valueType = expression.valueType === "special" && arity === previousArity ? "special" : getValueType(field, operator);
+    // A dynamic value or a column stays valid across operators of the same arity.
+    let keepsValueType = (expression.valueType === "special" || expression.valueType === "column") && value === expression.value;
+    let valueType = keepsValueType ? expression.valueType : getValueType(field, operator);
     return { ...expression, operator, value, valueType };
 }
 /** Returns the node at `path`, or null when the path does not exist. */

package/es/filter/types.d.ts

@@ -15,31 +15,52 @@ export type FilterExpression = {
     type: "expression";
     column: string;
     operator: string;
-    value: string | string[] | Date | number | null;
+    value: string | string[] | Date | number | null | Array<string | FilterRangeEnd>;
     valueType: string;
 };
 /**
- * The value types understood by the Appframe filter element converter.
+ * One end of a range whose ends are not both plain values, such as a fixed
+ * date and another column. Plain ends may stay plain values next to it; they
+ * then take the expression's `valueType`.
+ *
+ * The framework's data API cannot read these, so a filter holding one is sent
+ * as a filter string. See `needsFilterString`.
+ */
+export type FilterRangeEnd = {
+    valueType: FilterValueType;
+    value: string | number | null;
+};
+/**
+ * The value types understood by the Appframe filter element converter, plus
+ * `column`, which compares with another column. Only the `api/filter/convert`
+ * endpoint reads `column`, so a filter using it is sent as a filter string.
  *
  * @see `appframe/Appframe.Web.Core/Filtering/FilterElementConverter.vb`
+ * @see `lib/FilterConversion/FilterObjectReader.cs`
  */
-export type FilterValueType = "string" | "number" | "boolean" | "uniqueidentifier" | "array" | "datetime" | "special" | "null";
+export type FilterValueType = "string" | "number" | "boolean" | "uniqueidentifier" | "array" | "datetime" | "special" | "column" | "null";
 /**
  * Canonical operator names. These are the lower-cased `eOperators` enum member
  * names as emitted by the server, including the two aliases the server
- * special-cases (`notequals` for `Not`, `notdatequals` for `NotDateEquals`).
+ * special-cases (`notequals` for `Not`, `notdatequals` for `NotDateEquals`),
+ * plus the whole-period checks (`islastweek` and so on), which only the
+ * `api/filter/convert` endpoint reads.
  *
  * @see `appframe/Appframe3.Common.Data/Filtering/eOperators.vb`
  */
-export type FilterOperator = "equals" | "notequals" | "greaterthan" | "greaterthanorequal" | "lessthan" | "lessthanorequal" | "beginswith" | "notbeginswith" | "endswith" | "notendswith" | "contains" | "notcontains" | "like" | "notlike" | "isnull" | "isnotnull" | "isblank" | "isnotblank" | "istrue" | "isfalse" | "inlist" | "notinlist" | "between" | "notbetween" | "dateequals" | "notdatequals" | "dategreaterthan" | "dategreaterthanorequal" | "datelessthan" | "datelessthanorequal" | "datebetween" | "datenotbetween";
+export type FilterOperator = "equals" | "notequals" | "greaterthan" | "greaterthanorequal" | "lessthan" | "lessthanorequal" | "beginswith" | "notbeginswith" | "endswith" | "notendswith" | "contains" | "notcontains" | "like" | "notlike" | "isnull" | "isnotnull" | "isblank" | "isnotblank" | "istrue" | "isfalse" | "inlist" | "notinlist" | "between" | "notbetween" | "dateequals" | "notdatequals" | "dategreaterthan" | "dategreaterthanorequal" | "datelessthan" | "datelessthanorequal" | "datebetween" | "datenotbetween" | "isbeyondthisyear" | "islaterthisyear" | "islaterthismonth" | "isnextweek" | "islaterthisweek" | "istomorrow" | "istoday" | "isyesterday" | "isearlierthisweek" | "islastweek" | "isearlierthismonth" | "isearlierthisyear" | "ispriorthisyear";
 /**
  * Dynamic ("special") filter values. These are resolved server-side into a
  * relative date or the current user name, and are sent with
  * `valueType: "special"`.
  *
+ * `Now`, `DayAfterTomorrow` and `TwoWeeksAway` are offered by the Windows
+ * filter editor but have no `eDynamicValue` member, so a filter using them is
+ * sent as a filter string.
+ *
  * @see `appframe/Appframe3.Common.Data/Filtering/eDynamicValue.vb`
  */
-export type DynamicValue = "CurrentUser" | "Yesterday" | "Today" | "Tomorrow" | "ThisWeek" | "ThisMonth" | "ThisYear" | "LastWeek" | "LastMonth" | "LastYear" | "NextWeek" | "NextMonth" | "NextYear" | "UserYesterday" | "UserToday" | "UserTomorrow" | "UserThisWeek" | "UserThisMonth" | "UserThisYear" | "UserLastWeek" | "UserLastMonth" | "UserLastYear" | "UserNextWeek" | "UserNextMonth" | "UserNextYear";
+export type DynamicValue = "CurrentUser" | "Yesterday" | "Today" | "Now" | "Tomorrow" | "DayAfterTomorrow" | "TwoWeeksAway" | "ThisWeek" | "ThisMonth" | "ThisYear" | "LastWeek" | "LastMonth" | "LastYear" | "NextWeek" | "NextMonth" | "NextYear" | "UserYesterday" | "UserToday" | "UserTomorrow" | "UserThisWeek" | "UserThisMonth" | "UserThisYear" | "UserLastWeek" | "UserLastMonth" | "UserLastYear" | "UserNextWeek" | "UserNextMonth" | "UserNextYear";
 /**
  * The simplified data types the filter builder groups fields into. Mirrors the
  * normalized `DataType` column on `sviw_WebSiteCMS_FilterBuilder_ViewFields`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olenbetong/appframe-core",
-  "version": "2.15.2",
+  "version": "2.16.0",
   "description": "Javascript libraries to utilize the Appframe framework",
   "type": "module",
   "sideEffects": [
@@ -40,9 +40,11 @@
     "mitt": "^3.0.1"
   },
   "devDependencies": {
-    "@happy-dom/global-registrator": "20.14.5",
-    "@types/bun": "^1.4.2",
-    "chalk": "^6.0.1"
+    "@happy-dom/global-registrator": "21.0.4",
+    "@types/bun": "^1.4.4",
+    "chalk": "^6.0.1",
+    "typescript": "7.0.2",
+    "vitest": "5.0.5"
   },
   "peerDependencies": {},
   "optionalDependencies": {},