@pibit.ai/cure-design-system 0.6.36 → 0.6.38

package/dist/patterns/filter-group/types.js

@@ -0,0 +1,222 @@
+const n = [
+  {
+    label: "is empty",
+    id: "empty",
+    applicableTo: ["string", "number", "float", "list", "date", "dict", "boolean"],
+    requiresValue: !1
+  },
+  {
+    label: "is not empty",
+    id: "notEmpty",
+    applicableTo: ["string", "number", "float", "list", "date", "dict", "boolean"],
+    requiresValue: !1
+  },
+  {
+    label: "exists",
+    id: "exists",
+    applicableTo: ["string", "number", "float", "list", "date", "dict", "boolean"],
+    requiresValue: !1
+  },
+  {
+    label: "does not exist",
+    id: "notExists",
+    applicableTo: ["string", "number", "float", "list", "date", "dict", "boolean"],
+    requiresValue: !1
+  },
+  {
+    label: "name match using AI",
+    id: "name_match_using_ai",
+    applicableTo: ["string"],
+    requiresValue: !0
+  },
+  {
+    label: "name match using AI in List",
+    id: "name_match_using_ai_in_list",
+    applicableTo: ["string"],
+    requiresValue: !0
+  },
+  {
+    label: "equals",
+    id: "==",
+    applicableTo: ["string", "number", "float", "date", "boolean"],
+    requiresValue: !0
+  },
+  {
+    label: "not equals",
+    id: "!=",
+    applicableTo: ["string", "number", "float", "date", "boolean"],
+    requiresValue: !0
+  },
+  {
+    label: "greater than",
+    id: ">",
+    applicableTo: ["number", "float", "date"],
+    requiresValue: !0
+  },
+  {
+    label: "greater than or equal",
+    id: ">=",
+    applicableTo: ["number", "float", "date"],
+    requiresValue: !0
+  },
+  {
+    label: "less than",
+    id: "<",
+    applicableTo: ["number", "float", "date"],
+    requiresValue: !0
+  },
+  {
+    label: "less than or equal",
+    id: "<=",
+    applicableTo: ["number", "float", "date"],
+    requiresValue: !0
+  },
+  {
+    label: "in",
+    id: "in",
+    applicableTo: ["string"],
+    requiresValue: !0,
+    requiresMultipleValues: !0
+  },
+  {
+    label: "not in",
+    id: "notIn",
+    applicableTo: ["string"],
+    requiresValue: !0,
+    requiresMultipleValues: !0
+  },
+  {
+    label: "present in",
+    id: "presentIn",
+    applicableTo: ["string"],
+    requiresValue: !0,
+    requiresMultipleValues: !0
+  },
+  {
+    label: "not present in",
+    id: "notPresentIn",
+    applicableTo: ["string"],
+    requiresValue: !0,
+    requiresMultipleValues: !0
+  },
+  {
+    label: "contains",
+    id: "contains",
+    applicableTo: ["string", "list"],
+    requiresValue: !0
+  },
+  {
+    label: "Does not contains",
+    id: "notContains",
+    applicableTo: ["string", "list"],
+    requiresValue: !0
+  },
+  {
+    label: "Contains all",
+    id: "containsAll",
+    applicableTo: ["list"],
+    requiresValue: !0,
+    requiresMultipleValues: !0
+  },
+  {
+    label: "Contains any",
+    id: "containsAny",
+    applicableTo: ["list"],
+    requiresValue: !0,
+    requiresMultipleValues: !0
+  },
+  {
+    label: "Contains none",
+    id: "containsNone",
+    applicableTo: ["list"],
+    requiresValue: !0,
+    requiresMultipleValues: !0
+  },
+  {
+    label: "Is true",
+    id: "isTrue",
+    applicableTo: ["boolean"],
+    requiresValue: !1
+  },
+  {
+    label: "Is false",
+    id: "isFalse",
+    applicableTo: ["boolean"],
+    requiresValue: !1
+  },
+  {
+    label: "Before",
+    id: "before",
+    applicableTo: ["date"],
+    requiresValue: !1
+  },
+  {
+    label: "After",
+    id: "after",
+    applicableTo: ["date"],
+    requiresValue: !0
+  },
+  {
+    label: "On or before",
+    id: "onOrBefore",
+    applicableTo: ["date"],
+    requiresValue: !0
+  },
+  {
+    label: "On or After",
+    id: "onOrAfter",
+    applicableTo: ["date"],
+    requiresValue: !0
+  },
+  {
+    label: "Between",
+    id: "between",
+    applicableTo: ["date"],
+    requiresValue: !0
+  },
+  {
+    label: "Regex matches",
+    id: "regexMatch",
+    applicableTo: ["string", "number", "float"],
+    requiresValue: !0
+  },
+  {
+    label: "Regex does not matches",
+    id: "regexNotMatch",
+    applicableTo: ["string", "number", "float"],
+    requiresValue: !0
+  },
+  {
+    label: "Starts with",
+    id: "startsWith",
+    applicableTo: ["string"],
+    requiresValue: !0
+  },
+  {
+    label: "Ends with",
+    id: "endsWith",
+    applicableTo: ["string"],
+    requiresValue: !0
+  }
+], i = () => crypto.randomUUID(), p = (l, t = n) => {
+  var a;
+  const e = l[0], r = (e == null ? void 0 : e.type) || "string", u = ((a = t.filter((s) => s.applicableTo.includes(r))[0]) == null ? void 0 : a.id) || "";
+  return {
+    id: i(),
+    type: "condition",
+    fieldId: (e == null ? void 0 : e.id) || "",
+    operatorId: u,
+    value: ""
+  };
+}, b = (l = "and") => ({
+  id: i(),
+  type: "group",
+  operator: l,
+  children: []
+});
+export {
+  n as DEFAULT_OPERATORS,
+  p as createEmptyCondition,
+  b as createEmptyGroup,
+  i as generateId
+};

package/dist/patterns/filter-group/use-filter-group.d.ts

@@ -0,0 +1,38 @@
+import { FilterGroup, FilterField, FilterOperator, FilterLogicalOperator } from './types';
+export interface UseFilterGroupOptions {
+    /** Initial filter group state */
+    initialValue?: FilterGroup;
+    /** Available fields for filtering */
+    fields: FilterField[];
+    /** Available operators */
+    operators?: FilterOperator[];
+    /** Callback when filters change */
+    onChange?: (value: FilterGroup) => void;
+}
+export interface UseFilterGroupReturn {
+    /** Current filter group state */
+    filterGroup: FilterGroup;
+    /** Update the entire filter group */
+    setFilterGroup: (group: FilterGroup) => void;
+    /** Add a condition at the root level */
+    addCondition: () => void;
+    /** Add a nested group at the root level */
+    addGroup: (operator?: FilterLogicalOperator) => void;
+    /** Clear all filters */
+    clearAll: () => void;
+    /** Check if there are any active filters */
+    hasFilters: boolean;
+    /** Get the count of active conditions */
+    conditionCount: number;
+    /** Convert to a query-friendly format */
+    toQueryParams: () => Record<string, unknown>;
+    /** Check if the filter configuration is valid */
+    isValid: boolean;
+}
+/**
+ * Hook for managing filter group state
+ * Provides utilities for common operations and state management
+ */
+export declare const useFilterGroup: ({ initialValue, fields, operators, onChange, }: UseFilterGroupOptions) => UseFilterGroupReturn;
+export default useFilterGroup;
+//# sourceMappingURL=use-filter-group.d.ts.map

package/dist/patterns/filter-group/use-filter-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-filter-group.d.ts","sourceRoot":"","sources":["../../../src/patterns/filter-group/use-filter-group.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAA+B,WAAW,EAAE,cAAc,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAG5H,MAAM,WAAW,qBAAqB;IAClC,iCAAiC;IACjC,YAAY,CAAC,EAAE,WAAW,CAAC;IAC3B,qCAAqC;IACrC,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,0BAA0B;IAC1B,SAAS,CAAC,EAAE,cAAc,EAAE,CAAC;IAC7B,mCAAmC;IACnC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;CAC3C;AAED,MAAM,WAAW,oBAAoB;IACjC,iCAAiC;IACjC,WAAW,EAAE,WAAW,CAAC;IACzB,qCAAqC;IACrC,cAAc,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAC;IAC7C,wCAAwC;IACxC,YAAY,EAAE,MAAM,IAAI,CAAC;IACzB,2CAA2C;IAC3C,QAAQ,EAAE,CAAC,QAAQ,CAAC,EAAE,qBAAqB,KAAK,IAAI,CAAC;IACrD,wBAAwB;IACxB,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,4CAA4C;IAC5C,UAAU,EAAE,OAAO,CAAC;IACpB,yCAAyC;IACzC,cAAc,EAAE,MAAM,CAAC;IACvB,yCAAyC;IACzC,aAAa,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC7C,iDAAiD;IACjD,OAAO,EAAE,OAAO,CAAC;CACpB;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,gDAK5B,qBAAqB,KAAG,oBAsH1B,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/dist/patterns/filter-group/use-filter-group.js

@@ -0,0 +1,81 @@
+import { useState as b, useCallback as o, useMemo as m } from "react";
+import { createEmptyGroup as v, createEmptyCondition as I, DEFAULT_OPERATORS as O } from "./types.js";
+const R = ({
+  initialValue: G,
+  fields: s,
+  operators: l = O,
+  onChange: a
+}) => {
+  const [r, q] = b(G || v("and")), c = o(
+    (e) => {
+      q(e), a == null || a(e);
+    },
+    [a]
+  ), F = o(() => {
+    const e = I(s, l);
+    c({
+      ...r,
+      children: [...r.children, e]
+    });
+  }, [r, s, l, c]), E = o(
+    (e) => {
+      const i = v(e || (r.operator === "and" ? "or" : "and"));
+      i.children = [I(s, l)], c({
+        ...r,
+        children: [...r.children, i]
+      });
+    },
+    [r, s, l, c]
+  ), V = o(() => {
+    c(v("and"));
+  }, [c]), f = o((e) => e.type === "condition" ? 1 : e.children.reduce((i, t) => i + f(t), 0), []), y = m(
+    () => r.children.reduce((e, i) => e + f(i), 0),
+    [r, f]
+  ), w = y > 0, p = o(
+    (e) => {
+      if (e.type === "condition") {
+        const t = e;
+        if (!t.fieldId || !t.operatorId) return !1;
+        const u = l.find((d) => d.id === t.operatorId);
+        return !(u != null && u.requiresValue && !t.value || u != null && u.requiresTwoValues && (!t.value || !t.value2));
+      }
+      const i = e;
+      return i.children.length === 0 ? !0 : i.children.every((t) => p(t));
+    },
+    [l]
+  ), A = m(() => r.children.length === 0 ? !0 : r.children.every((e) => p(e)), [r, p]), S = o(() => {
+    const e = (t) => {
+      if (t.type === "condition") {
+        const n = t;
+        if (!n.fieldId || !n.operatorId) return null;
+        const h = l.find((T) => T.id === n.operatorId);
+        return h != null && h.requiresValue && !n.value ? null : {
+          field: n.fieldId,
+          operator: n.operatorId,
+          value: n.value,
+          ...n.value2 && { value2: n.value2 }
+        };
+      }
+      const u = t, d = u.children.map((n) => e(n)).filter(Boolean);
+      return d.length === 0 ? null : d.length === 1 ? d[0] : {
+        [u.operator]: d
+      };
+    };
+    return e(r) || {};
+  }, [r, l]);
+  return {
+    filterGroup: r,
+    setFilterGroup: c,
+    addCondition: F,
+    addGroup: E,
+    clearAll: V,
+    hasFilters: w,
+    conditionCount: y,
+    toQueryParams: S,
+    isValid: A
+  };
+};
+export {
+  R as default,
+  R as useFilterGroup
+};

package/dist/patterns/filter-group/validation.d.ts

@@ -0,0 +1,13 @@
+import { FilterGroup, FilterOperator } from './types';
+/**
+ * Validates a filter group and returns a Set of invalid condition IDs
+ * @param group The filter group to validate
+ * @param operators Available operators
+ * @returns Set of condition IDs that are invalid
+ */
+export declare const validateFilterGroup: (group: FilterGroup, operators?: FilterOperator[]) => Set<string>;
+/**
+ * Checks if a filter group is valid (all conditions are complete)
+ */
+export declare const isFilterGroupValid: (group: FilterGroup, operators?: FilterOperator[]) => boolean;
+//# sourceMappingURL=validation.d.ts.map

package/dist/patterns/filter-group/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/patterns/filter-group/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAA+B,cAAc,EAAE,MAAM,SAAS,CAAC;AAoDxF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,GAC5B,OAAO,WAAW,EAClB,YAAW,cAAc,EAAsB,KAChD,GAAG,CAAC,MAAM,CAcZ,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,GAAI,OAAO,WAAW,EAAE,YAAW,cAAc,EAAsB,KAAG,OAGxG,CAAC"}

package/dist/patterns/filter-group/validation.js

@@ -0,0 +1,19 @@
+import { DEFAULT_OPERATORS as l } from "./types.js";
+const f = (e, t = l) => {
+  var i, a, n;
+  if (!e.fieldId || !e.operatorId)
+    return !1;
+  const r = t.find((u) => u.id === e.operatorId);
+  return !(!r || r.requiresValue && !((i = e.value) != null && i.trim()) || r.requiresTwoValues && (!((a = e.value) != null && a.trim()) || !((n = e.value2) != null && n.trim())));
+}, s = (e, t = l, r = /* @__PURE__ */ new Set()) => (e.type === "condition" ? f(e, t) || r.add(e.id) : e.children.forEach((i) => {
+  s(i, t, r);
+}), r), d = (e, t = l) => {
+  const r = /* @__PURE__ */ new Set();
+  return e.children.length === 0 || e.children.forEach((i) => {
+    s(i, t, r);
+  }), r;
+}, c = (e, t = l) => d(e, t).size === 0;
+export {
+  c as isFilterGroupValid,
+  d as validateFilterGroup
+};