@johly/bits-ui 2.18.1

package/dist/bits/filter/operators.js

@@ -0,0 +1,356 @@
+export const DEFAULT_OPERATORS = {
+    text: {
+        single: "contains",
+        multiple: "contains",
+    },
+    number: {
+        single: "is",
+        multiple: "is between",
+    },
+    bigint: {
+        single: "is",
+        multiple: "is between",
+    },
+    date: {
+        single: "is",
+        multiple: "is between",
+    },
+    boolean: {
+        single: "is",
+        multiple: "is",
+    },
+    option: {
+        single: "is",
+        multiple: "is any of",
+    },
+    multiOption: {
+        single: "include",
+        multiple: "include any of",
+    },
+};
+export const optionFilterOperators = {
+    is: {
+        key: "filters.option.is",
+        value: "is",
+        target: "single",
+        singularOf: "is any of",
+        relativeOf: "is not",
+        isNegated: false,
+        negation: "is not",
+    },
+    "is not": {
+        key: "filters.option.isNot",
+        value: "is not",
+        target: "single",
+        singularOf: "is none of",
+        relativeOf: "is",
+        isNegated: true,
+        negationOf: "is",
+    },
+    "is any of": {
+        key: "filters.option.isAnyOf",
+        value: "is any of",
+        target: "multiple",
+        pluralOf: "is",
+        relativeOf: "is none of",
+        isNegated: false,
+        negation: "is none of",
+    },
+    "is none of": {
+        key: "filters.option.isNoneOf",
+        value: "is none of",
+        target: "multiple",
+        pluralOf: "is not",
+        relativeOf: "is any of",
+        isNegated: true,
+        negationOf: "is any of",
+    },
+};
+export const multiOptionFilterOperators = {
+    include: {
+        key: "filters.multiOption.include",
+        value: "include",
+        target: "single",
+        singularOf: "include any of",
+        relativeOf: "exclude",
+        isNegated: false,
+        negation: "exclude",
+    },
+    exclude: {
+        key: "filters.multiOption.exclude",
+        value: "exclude",
+        target: "single",
+        singularOf: "exclude if any of",
+        relativeOf: "include",
+        isNegated: true,
+        negationOf: "include",
+    },
+    "include any of": {
+        key: "filters.multiOption.includeAnyOf",
+        value: "include any of",
+        target: "multiple",
+        pluralOf: "include",
+        relativeOf: ["exclude if all", "include all of", "exclude if any of"],
+        isNegated: false,
+        negation: "exclude if all",
+    },
+    "exclude if all": {
+        key: "filters.multiOption.excludeIfAll",
+        value: "exclude if all",
+        target: "multiple",
+        pluralOf: "exclude",
+        relativeOf: ["include any of", "include all of", "exclude if any of"],
+        isNegated: true,
+        negationOf: "include any of",
+    },
+    "include all of": {
+        key: "filters.multiOption.includeAllOf",
+        value: "include all of",
+        target: "multiple",
+        pluralOf: "include",
+        relativeOf: ["include any of", "exclude if all", "exclude if any of"],
+        isNegated: false,
+        negation: "exclude if any of",
+    },
+    "exclude if any of": {
+        key: "filters.multiOption.excludeIfAnyOf",
+        value: "exclude if any of",
+        target: "multiple",
+        pluralOf: "exclude",
+        relativeOf: ["include any of", "exclude if all", "include all of"],
+        isNegated: true,
+        negationOf: "include all of",
+    },
+};
+export const dateFilterOperators = {
+    is: {
+        key: "filters.date.is",
+        value: "is",
+        target: "single",
+        singularOf: "is between",
+        relativeOf: "is after",
+        isNegated: false,
+        negation: "is before",
+    },
+    "is not": {
+        key: "filters.date.isNot",
+        value: "is not",
+        target: "single",
+        singularOf: "is not between",
+        relativeOf: ["is", "is before", "is on or after", "is after", "is on or before"],
+        isNegated: true,
+        negationOf: "is",
+    },
+    "is before": {
+        key: "filters.date.isBefore",
+        value: "is before",
+        target: "single",
+        singularOf: "is between",
+        relativeOf: ["is", "is not", "is on or after", "is after", "is on or before"],
+        isNegated: false,
+        negation: "is on or after",
+    },
+    "is on or after": {
+        key: "filters.date.isOnOrAfter",
+        value: "is on or after",
+        target: "single",
+        singularOf: "is between",
+        relativeOf: ["is", "is not", "is before", "is after", "is on or before"],
+        isNegated: false,
+        negation: "is before",
+    },
+    "is after": {
+        key: "filters.date.isAfter",
+        value: "is after",
+        target: "single",
+        singularOf: "is between",
+        relativeOf: ["is", "is not", "is before", "is on or after", "is on or before"],
+        isNegated: false,
+        negation: "is on or before",
+    },
+    "is on or before": {
+        key: "filters.date.isOnOrBefore",
+        value: "is on or before",
+        target: "single",
+        singularOf: "is between",
+        relativeOf: ["is", "is not", "is after", "is on or after", "is before"],
+        isNegated: false,
+        negation: "is after",
+    },
+    "is between": {
+        key: "filters.date.isBetween",
+        value: "is between",
+        target: "multiple",
+        pluralOf: "is",
+        relativeOf: "is not between",
+        isNegated: false,
+        negation: "is not between",
+    },
+    "is not between": {
+        key: "filters.date.isNotBetween",
+        value: "is not between",
+        target: "multiple",
+        pluralOf: "is not",
+        relativeOf: "is between",
+        isNegated: true,
+        negationOf: "is between",
+    },
+};
+export const textFilterOperators = {
+    contains: {
+        key: "filters.text.contains",
+        value: "contains",
+        target: "single",
+        relativeOf: "does not contain",
+        isNegated: false,
+        negation: "does not contain",
+    },
+    "does not contain": {
+        key: "filters.text.doesNotContain",
+        value: "does not contain",
+        target: "single",
+        relativeOf: "contains",
+        isNegated: true,
+        negationOf: "contains",
+    },
+};
+export const numberFilterOperators = {
+    is: {
+        key: "filters.number.is",
+        value: "is",
+        target: "single",
+        singularOf: "is between",
+        relativeOf: [
+            "is not",
+            "is greater than",
+            "is less than or equal to",
+            "is less than",
+            "is greater than or equal to",
+        ],
+        isNegated: false,
+        negation: "is not",
+    },
+    "is not": {
+        key: "filters.number.isNot",
+        value: "is not",
+        target: "single",
+        singularOf: "is not between",
+        relativeOf: [
+            "is",
+            "is greater than",
+            "is less than or equal to",
+            "is less than",
+            "is greater than or equal to",
+        ],
+        isNegated: true,
+        negationOf: "is",
+    },
+    "is greater than": {
+        key: "filters.number.greaterThan",
+        value: "is greater than",
+        target: "single",
+        singularOf: "is between",
+        relativeOf: [
+            "is",
+            "is not",
+            "is less than or equal to",
+            "is less than",
+            "is greater than or equal to",
+        ],
+        isNegated: false,
+        negation: "is less than or equal to",
+    },
+    "is greater than or equal to": {
+        key: "filters.number.greaterThanOrEqual",
+        value: "is greater than or equal to",
+        target: "single",
+        singularOf: "is between",
+        relativeOf: ["is", "is not", "is greater than", "is less than or equal to", "is less than"],
+        isNegated: false,
+        negation: "is less than or equal to",
+    },
+    "is less than": {
+        key: "filters.number.lessThan",
+        value: "is less than",
+        target: "single",
+        singularOf: "is between",
+        relativeOf: [
+            "is",
+            "is not",
+            "is greater than",
+            "is less than or equal to",
+            "is greater than or equal to",
+        ],
+        isNegated: false,
+        negation: "is greater than",
+    },
+    "is less than or equal to": {
+        key: "filters.number.lessThanOrEqual",
+        value: "is less than or equal to",
+        target: "single",
+        singularOf: "is between",
+        relativeOf: ["is", "is not", "is greater than", "is less than", "is greater than or equal to"],
+        isNegated: false,
+        negation: "is greater than or equal to",
+    },
+    "is between": {
+        key: "filters.number.isBetween",
+        value: "is between",
+        target: "multiple",
+        pluralOf: "is",
+        relativeOf: "is not between",
+        isNegated: false,
+        negation: "is not between",
+    },
+    "is not between": {
+        key: "filters.number.isNotBetween",
+        value: "is not between",
+        target: "multiple",
+        pluralOf: "is not",
+        relativeOf: "is between",
+        isNegated: true,
+        negationOf: "is between",
+    },
+};
+export const bigIntFilterOperators = numberFilterOperators;
+export const booleanFilterOperators = {
+    is: {
+        key: "filters.boolean.is",
+        value: "is",
+        target: "single",
+        singularOf: "is not",
+        relativeOf: "is not",
+        isNegated: false,
+        negation: "is not",
+    },
+    "is not": {
+        key: "filters.boolean.isNot",
+        value: "is not",
+        target: "single",
+        singularOf: "is",
+        relativeOf: "is",
+        isNegated: true,
+        negationOf: "is",
+    },
+};
+export const filterTypeOperatorDetails = {
+    text: textFilterOperators,
+    number: numberFilterOperators,
+    bigint: bigIntFilterOperators,
+    date: dateFilterOperators,
+    boolean: booleanFilterOperators,
+    option: optionFilterOperators,
+    multiOption: multiOptionFilterOperators,
+};
+export function determineNewOperator(type, oldVals, nextVals, currentOperator) {
+    const a = Array.isArray(oldVals) && Array.isArray(oldVals[0]) ? oldVals[0].length : oldVals.length;
+    const b = Array.isArray(nextVals) && Array.isArray(nextVals[0]) ? nextVals[0].length : nextVals.length;
+    if (a === b || (a >= 2 && b >= 2) || (a <= 1 && b <= 1))
+        return currentOperator;
+    const opDetails = filterTypeOperatorDetails[type][currentOperator];
+    if (a < b && b >= 2)
+        return opDetails.singularOf ?? currentOperator;
+    if (a > b && b <= 1)
+        return opDetails.pluralOf ?? currentOperator;
+    return currentOperator;
+}

package/dist/bits/filter/order-fns.d.ts

@@ -0,0 +1,14 @@
+import type { ColumnOption, OrderDirection, TBuiltInOrderFnName, TCustomOrderFn, TOrderFnArg, TOrderFns } from "./types.js";
+declare function count(a: ColumnOption, b: ColumnOption, direction: OrderDirection): number;
+declare function label(a: ColumnOption, b: ColumnOption, direction: OrderDirection): number;
+export declare const orderFns: {
+    readonly count: typeof count;
+    readonly label: typeof label;
+};
+export declare function applyOrderFns(orderFns: TOrderFns, options: ColumnOption[]): ColumnOption[];
+export declare function isBuiltInOrderFnName(value: unknown): value is TBuiltInOrderFnName;
+export declare function isOrderDirection(value: unknown): value is OrderDirection;
+export declare function isCustomOrderFn(value: unknown): value is TCustomOrderFn;
+export declare function isBuiltInOrderFnTuple(value: unknown): value is [TBuiltInOrderFnName, OrderDirection];
+export declare function isOrderFnArg(value: unknown): value is TOrderFnArg;
+export {};

package/dist/bits/filter/order-fns.js

@@ -0,0 +1,42 @@
+function count(a, b, direction) {
+    const x = a.count ?? 0;
+    const y = b.count ?? 0;
+    return direction === "asc" ? x - y : y - x;
+}
+function label(a, b, direction) {
+    const x = a.label.toLowerCase();
+    const y = b.label.toLowerCase();
+    return direction === "asc" ? x.localeCompare(y) : y.localeCompare(x);
+}
+export const orderFns = {
+    count,
+    label,
+};
+export function applyOrderFns(orderFns, options) {
+    return [...options].sort((a, b) => {
+        for (const orderFn of orderFns) {
+            const result = orderFn(a, b);
+            if (result !== 0)
+                return result;
+        }
+        return 0;
+    });
+}
+export function isBuiltInOrderFnName(value) {
+    return typeof value === "string" && value in orderFns;
+}
+export function isOrderDirection(value) {
+    return typeof value === "string" && (value === "asc" || value === "desc");
+}
+export function isCustomOrderFn(value) {
+    return typeof value === "function" && value.length === 2;
+}
+export function isBuiltInOrderFnTuple(value) {
+    return (Array.isArray(value) &&
+        value.length === 2 &&
+        isBuiltInOrderFnName(value[0]) &&
+        isOrderDirection(value[1]));
+}
+export function isOrderFnArg(value) {
+    return isBuiltInOrderFnTuple(value) || isCustomOrderFn(value);
+}

package/dist/bits/filter/type-guards.d.ts

@@ -0,0 +1,21 @@
+import type { Column, ColumnDataType, FilterModel } from "./types.js";
+export declare function isColumnType<TData, TType extends ColumnDataType>(column: Column<TData>, type: TType): column is Column<TData, TType>;
+export declare function isTextColumn<TData>(column: Column<TData>): column is Column<TData, "text">;
+export declare function isOptionColumn<TData>(column: Column<TData>): column is Column<TData, "option">;
+export declare function isMultiOptionColumn<TData>(column: Column<TData>): column is Column<TData, "multiOption">;
+export declare function isOptionBasedColumn<TData>(column: Column<TData>): column is Column<TData, "option"> | Column<TData, "multiOption">;
+export declare function isDateColumn<TData>(column: Column<TData>): column is Column<TData, "date">;
+export declare function isNumberColumn<TData>(column: Column<TData>): column is Column<TData, "number">;
+export declare function isBigIntColumn<TData>(column: Column<TData>): column is Column<TData, "bigint">;
+export declare function isNumericColumn<TData>(column: Column<TData>): column is Column<TData, "number"> | Column<TData, "bigint">;
+export declare function isBooleanColumn<TData>(column: Column<TData>): column is Column<TData, "boolean">;
+export declare function isFilterType<TType extends ColumnDataType>(filter: FilterModel, type: TType): filter is FilterModel<TType>;
+export declare function isTextFilter(filter: FilterModel): filter is FilterModel<"text">;
+export declare function isOptionFilter(filter: FilterModel): filter is FilterModel<"option">;
+export declare function isMultiOptionFilter(filter: FilterModel): filter is FilterModel<"multiOption">;
+export declare function isOptionBasedFilter(filter: FilterModel): filter is FilterModel<"option"> | FilterModel<"multiOption">;
+export declare function isDateFilter(filter: FilterModel): filter is FilterModel<"date">;
+export declare function isNumberFilter(filter: FilterModel): filter is FilterModel<"number">;
+export declare function isBigIntFilter(filter: FilterModel): filter is FilterModel<"bigint">;
+export declare function isNumericFilter(filter: FilterModel): filter is FilterModel<"number"> | FilterModel<"bigint">;
+export declare function isBooleanFilter(filter: FilterModel): filter is FilterModel<"boolean">;

package/dist/bits/filter/type-guards.js

@@ -0,0 +1,60 @@
+export function isColumnType(column, type) {
+    return column.type === type;
+}
+export function isTextColumn(column) {
+    return column.type === "text";
+}
+export function isOptionColumn(column) {
+    return column.type === "option";
+}
+export function isMultiOptionColumn(column) {
+    return column.type === "multiOption";
+}
+export function isOptionBasedColumn(column) {
+    return column.type === "option" || column.type === "multiOption";
+}
+export function isDateColumn(column) {
+    return column.type === "date";
+}
+export function isNumberColumn(column) {
+    return column.type === "number";
+}
+export function isBigIntColumn(column) {
+    return column.type === "bigint";
+}
+export function isNumericColumn(column) {
+    return column.type === "number" || column.type === "bigint";
+}
+export function isBooleanColumn(column) {
+    return column.type === "boolean";
+}
+export function isFilterType(filter, type) {
+    return filter.type === type;
+}
+export function isTextFilter(filter) {
+    return filter.type === "text";
+}
+export function isOptionFilter(filter) {
+    return filter.type === "option";
+}
+export function isMultiOptionFilter(filter) {
+    return filter.type === "multiOption";
+}
+export function isOptionBasedFilter(filter) {
+    return filter.type === "option" || filter.type === "multiOption";
+}
+export function isDateFilter(filter) {
+    return filter.type === "date";
+}
+export function isNumberFilter(filter) {
+    return filter.type === "number";
+}
+export function isBigIntFilter(filter) {
+    return filter.type === "bigint";
+}
+export function isNumericFilter(filter) {
+    return filter.type === "number" || filter.type === "bigint";
+}
+export function isBooleanFilter(filter) {
+    return filter.type === "boolean";
+}