@pol-studios/features 1.0.0

package/dist/index.js

@@ -0,0 +1,769 @@
+// src/comments/useComments.tsx
+import moment from "moment";
+import {
+  createContext,
+  useCallback,
+  useContext,
+  useMemo,
+  useState
+} from "react";
+import {
+  useDbDelete,
+  useQuery,
+  useDbRealtimeQuery,
+  useDbUpsert,
+  useSupabase
+} from "@pol-studios/db";
+import { useAuth } from "@pol-studios/auth";
+import { isUsable } from "@pol-studios/utils";
+import { Comment } from "@pol-studios/db";
+import { jsx } from "react/jsx-runtime";
+var CommentContext = createContext(null);
+function timeSinceOpened(timestamp) {
+  if (!timestamp) {
+    return "";
+  }
+  const openedTime = moment(timestamp);
+  return preciseHumanize(moment.duration(moment().diff(openedTime))) + " ago";
+}
+var preciseHumanize = (duration) => {
+  const years = duration.years();
+  const months = duration.months();
+  const days = duration.days();
+  const hours = duration.hours();
+  const minutes = duration.minutes();
+  if (duration.asMinutes() < 1) {
+    return "a few seconds";
+  } else if (duration.years() > 0) {
+    return `${years} year${years !== 1 ? "s" : ""}`;
+  } else if (duration.months() > 0) {
+    return `${months} month${months !== 1 ? "s" : ""}`;
+  } else if (duration.days() > 0) {
+    return `${days} day${days !== 1 ? "s" : ""}`;
+  }
+  return `${hours > 0 ? `${hours} hour${hours !== 1 ? "s" : ""} ` : ""}${minutes > 0 ? `${minutes} minute${minutes !== 1 ? "s" : ""} ` : ""}`;
+};
+function CommentProvider({
+  children,
+  entityTableName,
+  entityId,
+  schemaName = "public"
+}) {
+  const auth = useAuth();
+  const supabase = useSupabase();
+  const tagUpsert = useDbUpsert(
+    { schema: "core", table: "CommentTag" },
+    ["id"],
+    "*"
+  );
+  const upsert = useDbUpsert({ schema: "core", table: "Comment" }, ["id"], "*");
+  const upsertSection = useDbUpsert(
+    { schema: "core", table: "CommentSection" },
+    ["id"],
+    "*"
+  );
+  const reaction = useDbUpsert(
+    { schema: "core", table: "CommentReaction" },
+    ["id"],
+    "*"
+  );
+  const reactionDelete = useDbDelete(
+    { schema: "core", table: "CommentReaction" },
+    ["id"]
+  );
+  const readUpsert = useDbUpsert(
+    { schema: "core", table: "CommentRead" },
+    ["id"],
+    "*"
+  );
+  const deleteCommentMutation = useDbDelete(
+    { schema: "core", table: "Comment" },
+    ["id"]
+  );
+  const [quote, setQuote] = useState(null);
+  const [message, setMessage] = useState("");
+  const [showMore, setShowMore] = useState(false);
+  const [taggedUserIds, setTaggedUserIds] = useState([]);
+  const shouldLoadProfiles = useMemo(
+    () => Boolean(auth?.user?.id),
+    [auth?.user?.id]
+  );
+  const usersRequest = useQuery(
+    supabase.schema("core").from("Profile").select("*"),
+    { enabled: shouldLoadProfiles }
+  );
+  const commentSectionRequest = useDbRealtimeQuery(
+    supabase.schema("core").from("CommentSection").select("*", { count: "exact" }).eq("entityId", entityId).eq("tableName", entityTableName).eq("schemaName", schemaName).maybeSingle()
+  );
+  const commentSectionId = commentSectionRequest.data?.id;
+  const hasCommentSectionId = isUsable(commentSectionId);
+  const commentsRequest = useDbRealtimeQuery(
+    supabase.schema("core").from("Comment").select(
+      `${Comment.defaultQuery}, CommentReaction(id, value, commentId, userId), CommentRead(id, userId, commentId)`,
+      { count: "exact" }
+    ).eq("commentSectionId", commentSectionId ?? "").order("createdAt", { ascending: false }),
+    { enabled: hasCommentSectionId }
+  );
+  const comments = useMemo(() => {
+    if (!isUsable(commentsRequest?.data)) return [];
+    return commentsRequest.data;
+  }, [commentsRequest?.data]);
+  const sendComment = useCallback(async () => {
+    if (message === "") return;
+    let nextCommentSectionId = commentSectionId;
+    if (!hasCommentSectionId) {
+      const newSection = {
+        entityId,
+        tableName: entityTableName,
+        schemaName
+      };
+      try {
+        const sectionResponse = await upsertSection.mutateAsync(newSection);
+        if (!sectionResponse?.id) {
+          throw new Error("Failed to create comment section: No ID returned.");
+        }
+        nextCommentSectionId = sectionResponse.id;
+        await commentSectionRequest.refetch();
+      } catch (error) {
+        console.error(
+          "Error creating comment section - full error:",
+          JSON.stringify(error, null, 2)
+        );
+        console.error("Error creating comment section - error object:", error);
+        let errorMessage = "Failed to create comment section.";
+        let errorDetails = "";
+        if (error && typeof error === "object") {
+          const supabaseError = error;
+          if (supabaseError.code) {
+            errorDetails += `[${supabaseError.code}] `;
+          }
+          if (supabaseError.message) {
+            errorMessage = supabaseError.message;
+          }
+          if (supabaseError.details) {
+            errorDetails += `Details: ${supabaseError.details}. `;
+          }
+          if (supabaseError.hint) {
+            errorDetails += `Hint: ${supabaseError.hint}. `;
+          }
+        } else if (error instanceof Error) {
+          errorMessage = error.message;
+        }
+        const fullErrorMessage = errorDetails ? `${errorMessage} ${errorDetails}`.trim() : errorMessage;
+        throw new Error(fullErrorMessage);
+      }
+    }
+    if (!nextCommentSectionId) {
+      throw new Error("Comment section ID is missing. Please try again.");
+    }
+    const newComment = {
+      commentSectionId: nextCommentSectionId,
+      message
+    };
+    if (quote !== null) {
+      newComment.parentId = quote.id;
+    }
+    const commentResponse = await upsert.mutateAsync(newComment);
+    await Promise.all(
+      taggedUserIds.map(
+        (userId) => tagUpsert.mutateAsync({
+          userId,
+          commentId: commentResponse.id
+        })
+      )
+    );
+    setShowMore(true);
+    setTaggedUserIds([]);
+    setMessage("");
+    setQuote(null);
+  }, [
+    commentSectionId,
+    commentSectionRequest.refetch,
+    entityId,
+    entityTableName,
+    hasCommentSectionId,
+    message,
+    quote,
+    schemaName,
+    setMessage,
+    setShowMore,
+    setTaggedUserIds,
+    setQuote,
+    tagUpsert,
+    taggedUserIds,
+    upsert,
+    upsertSection
+  ]);
+  const tagUser = useCallback(
+    (userId) => {
+      setTaggedUserIds((prev) => {
+        if (prev.includes(userId)) {
+          return prev.filter((user) => user !== userId);
+        }
+        return [...prev, userId];
+      });
+    },
+    [setTaggedUserIds]
+  );
+  const tryCommentReaction = useCallback(
+    async (value, commentId) => {
+      if (!auth?.user?.id || comments.length === 0) return;
+      const comment = comments.find((c) => c.id === commentId);
+      if (!comment) return;
+      if (comment.CommentReaction.some(
+        (x) => x.userId === auth.user.id && x.value === value
+      ))
+        return;
+      const reactionData = {
+        commentId,
+        value
+      };
+      await reaction.mutateAsync(reactionData);
+    },
+    [auth?.user?.id, comments, reaction]
+  );
+  const deleteReaction = useCallback(
+    async (reactionId) => {
+      await reactionDelete.mutateAsync({ id: reactionId });
+    },
+    [reactionDelete]
+  );
+  const readComment = useCallback(
+    async (commentId) => {
+      if (!auth?.user?.id || comments.length === 0) return;
+      const comment = comments.find((c) => c.id === commentId);
+      const reads = comment?.CommentRead;
+      if (!reads || reads.some((x) => x.userId === auth.user.id)) return;
+      await readUpsert.mutateAsync({ commentId });
+      await commentsRequest.refetch();
+    },
+    [auth?.user?.id, comments, commentsRequest, readUpsert]
+  );
+  const deleteComment = useCallback(
+    async (commentId) => {
+      await deleteCommentMutation.mutateAsync({ id: commentId });
+    },
+    [deleteCommentMutation]
+  );
+  const quoteInfo = useMemo(() => {
+    if (quote === null) return null;
+    return "- replying to " + quote.userName + "'s comment created " + timeSinceOpened(quote.createdAt);
+  }, [quote]);
+  const taggableUsers = useMemo(() => {
+    if (!auth?.user?.id || !isUsable(usersRequest.data)) return [];
+    return usersRequest.data.filter((user) => {
+      return user.id !== auth.user.id && !taggedUserIds.includes(user.id);
+    });
+  }, [auth?.user?.id, taggedUserIds, usersRequest.data]);
+  const taggedUsers = useMemo(() => {
+    if (!isUsable(usersRequest.data)) return [];
+    return usersRequest.data.filter((user) => taggedUserIds.includes(user.id));
+  }, [taggedUserIds, usersRequest.data]);
+  const commentSectionExists = useMemo(() => {
+    return hasCommentSectionId;
+  }, [hasCommentSectionId]);
+  const unreadCommentCount = useMemo(() => {
+    if (!auth?.user?.id || comments.length === 0) return 0;
+    return comments.filter(
+      (c) => !c.CommentRead.some((x) => x.userId === auth.user.id)
+    ).length;
+  }, [auth?.user?.id, comments]);
+  const contextValue = useMemo(
+    () => ({
+      deleteComment,
+      deleteReaction,
+      tryCommentReaction,
+      showMore,
+      setShowMore,
+      quote,
+      setQuote,
+      setMessage,
+      message,
+      sendComment,
+      quoteInfo,
+      comments,
+      commentSectionExists,
+      taggableUsers,
+      tagUser,
+      taggedUsers,
+      readComment,
+      unreadCommentCount
+    }),
+    [
+      commentSectionExists,
+      comments,
+      deleteComment,
+      deleteReaction,
+      message,
+      quote,
+      quoteInfo,
+      readComment,
+      sendComment,
+      showMore,
+      tagUser,
+      taggableUsers,
+      taggedUsers,
+      tryCommentReaction,
+      unreadCommentCount
+    ]
+  );
+  return /* @__PURE__ */ jsx(CommentContext.Provider, { value: contextValue, children });
+}
+var useComments = () => {
+  const context = useContext(CommentContext);
+  if (!context) {
+    throw new Error(
+      "useComments must be used within a CommentProvider"
+    );
+  }
+  return context;
+};
+
+// src/ordering/useOrderHint.ts
+import { isUsable as isUsable2 } from "@pol-studios/utils";
+var useOrderHint = () => {
+  const createOrderHint = (prevOrderHint, nextOrderHint) => {
+    let newOrderHint;
+    if (isNaN(prevOrderHint)) {
+      return 1;
+    }
+    if (isUsable2(nextOrderHint) === false || isNaN(nextOrderHint)) {
+      newOrderHint = prevOrderHint + 1;
+    } else if (isUsable2(prevOrderHint) === false) {
+      newOrderHint = nextOrderHint / 2;
+    } else {
+      newOrderHint = (prevOrderHint + nextOrderHint) / 2;
+    }
+    return newOrderHint;
+  };
+  return { createOrderHint };
+};
+var useOrderHint_default = useOrderHint;
+
+// src/ordering/useOrderManager.ts
+import { useEffect, useState as useState2 } from "react";
+import {
+  useDbRealtimeQuery as useDbRealtimeQuery2,
+  useDbUpsert as useDbUpsert2,
+  useSupabase as useSupabase2
+} from "@pol-studios/db";
+import { isUsable as isUsable3 } from "@pol-studios/utils";
+var useOrderManager = (table, items, property, schema = "public") => {
+  const [managedItems, setManagedItems] = useState2([]);
+  const [originalItems, setOriginalItems] = useState2([]);
+  const supabase = useSupabase2();
+  const upsert = useDbUpsert2(schema !== "public" ? { table, schema } : table, [
+    "id"
+  ]);
+  const orderHintRequest = property ? useDbRealtimeQuery2(
+    supabase.schema(schema).from(table).select("*", { count: "exact" }).in(
+      property,
+      items.map((x) => x.id)
+    )
+  ) : null;
+  useEffect(() => {
+    if (!property) {
+      const res2 = [];
+      (async () => {
+        for (const [index, item] of items.entries()) {
+          if (item.orderHint == null) {
+            await updateOrderHint(
+              item,
+              index > 0 ? Number(res2[index - 1].orderHint) : null,
+              null
+            );
+          }
+          res2.push({
+            ...item,
+            orderHint: Number(item.orderHint ?? index + 1)
+          });
+        }
+        res2.sort((a, b) => a.orderHint - b.orderHint);
+        setOriginalItems(res2);
+        setManagedItems(res2);
+      })();
+      return;
+    }
+    if (!orderHintRequest?.data) return;
+    const dataWithOrderHint = orderHintRequest.data;
+    let currMax = dataWithOrderHint.map((x) => Number(x.orderHint)).reduce((a, b) => Math.max(a, b), 0);
+    const res = [];
+    (async () => {
+      for (const item of items) {
+        const newItem = { ...item, orderHint: void 0 };
+        const orderHint = dataWithOrderHint.find(
+          (x) => x[property] === item.id
+        );
+        if (isUsable3(orderHint)) {
+          newItem.orderHint = Number(orderHint.orderHint);
+        } else {
+          await upsert.mutateAsync({
+            orderHint: String(currMax + 1),
+            [property]: item.id
+          });
+          currMax += 1;
+          newItem.orderHint = currMax;
+        }
+        res.push(newItem);
+      }
+      res.sort((a, b) => a.orderHint - b.orderHint);
+      setOriginalItems(res);
+      setManagedItems(res);
+    })();
+  }, [orderHintRequest?.data, items, property]);
+  const orderHintHelper = useOrderHint_default();
+  const updateOrderHint = async (activeItem, prevOrderHint, nextOrderHint) => {
+    let newOrderHint = orderHintHelper.createOrderHint(
+      prevOrderHint,
+      nextOrderHint
+    );
+    const newActiveItem = { ...activeItem, orderHint: newOrderHint };
+    const newManagedItems = managedItems.map(
+      (x) => x.id === activeItem.id ? newActiveItem : x
+    );
+    newManagedItems.sort((a, b) => a.orderHint - b.orderHint);
+    setManagedItems(newManagedItems);
+    if (!property) {
+      await upsert.mutateAsync({
+        id: activeItem.id,
+        orderHint: String(newOrderHint)
+      });
+      return;
+    }
+    try {
+      const dataWithOrderHint = orderHintRequest?.data;
+      const data = dataWithOrderHint?.find(
+        (x) => x[property] === activeItem.id
+      );
+      await upsert.mutateAsync({ ...data, orderHint: String(newOrderHint) });
+    } catch (error) {
+      setManagedItems(originalItems);
+    }
+  };
+  return { managedItems, updateOrderHint };
+};
+var useOrderManager_default = useOrderManager;
+
+// src/punch-list/usePunchListPage.ts
+import {
+  useSupabase as useSupabase3
+} from "@pol-studios/db";
+import { useEffect as useEffect2, useState as useState3 } from "react";
+import { useDbUpsert as useDbUpsert3 } from "@pol-studios/db";
+import { useAuth as useAuth2 } from "@pol-studios/auth";
+function usePunchListPage(relation, entityId) {
+  const supabase = useSupabase3();
+  const upsert = useDbUpsert3("PunchListPage", ["id"]);
+  const { user } = useAuth2();
+  const [punchListPageId, setPunchListPageId] = useState3(null);
+  const handleThis = async () => {
+    const punchListPage = await supabase.from("PunchListPage").select("id").eq("tableName", relation).eq("entityId", entityId).maybeSingle();
+    if (punchListPage.data) {
+      setPunchListPageId(punchListPage.data.id);
+      return;
+    }
+    await upsert.mutateAsync({
+      tableName: relation,
+      entityId,
+      createdBy: user?.id
+    });
+    const newPunchListPage = await supabase.from("PunchListPage").select("id").eq("tableName", relation).eq("entityId", entityId).maybeSingle();
+    if (newPunchListPage.data) {
+      setPunchListPageId(newPunchListPage.data.id);
+    }
+  };
+  useEffect2(() => {
+    handleThis();
+  }, [entityId]);
+  return punchListPageId;
+}
+
+// src/filter-utils/useFilterBuilder.tsx
+import { createContext as createContext2, useContext as useContext2 } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var hookOnChange = (options, onChange, curr, value, tableName, property) => {
+  if (!tableName) {
+    onChange({ ...curr, value });
+    return;
+  }
+  if (options) {
+    let filteredEntities;
+    switch (curr.op) {
+      case "=":
+        filteredEntities = options.filter((entity) => {
+          if (typeof property === "string") {
+            const nestedProperty = getPropertyKey(property);
+            return getProperty(nestedProperty, entity) === value;
+          }
+          return property.some((prop) => {
+            const nestedProperty = getPropertyKey(prop);
+            return getProperty(nestedProperty, entity) === value;
+          });
+        });
+        break;
+      case "contains":
+      case "ilike":
+        filteredEntities = options.filter((entity) => {
+          if (typeof property === "string") {
+            const nestedProperty = getPropertyKey(property);
+            const propValue = getProperty(nestedProperty, entity);
+            return propValue?.toString().toLowerCase().includes(value.toLowerCase());
+          }
+          return property.some((prop) => {
+            const nestedProperty = getPropertyKey(prop);
+            const propValue = getProperty(nestedProperty, entity);
+            return propValue?.toString().toLowerCase().includes(value.toLowerCase());
+          });
+        });
+        break;
+      case ">":
+        filteredEntities = options.filter((entity) => {
+          if (typeof property === "string") {
+            const nestedProperty = getPropertyKey(property);
+            return getProperty(nestedProperty, entity) > value;
+          }
+          return property.some((prop) => {
+            const nestedProperty = getPropertyKey(prop);
+            return getProperty(nestedProperty, entity) > value;
+          });
+        });
+        break;
+      case ">=":
+        filteredEntities = options.filter((entity) => {
+          if (typeof property === "string") {
+            const nestedProperty = getPropertyKey(property);
+            return getProperty(nestedProperty, entity) >= value;
+          }
+          return property.some((prop) => {
+            const nestedProperty = getPropertyKey(prop);
+            return getProperty(nestedProperty, entity) >= value;
+          });
+        });
+        break;
+      case "<":
+        filteredEntities = options.filter((entity) => {
+          if (typeof property === "string") {
+            const nestedProperty = getPropertyKey(property);
+            return getProperty(nestedProperty, entity) < value;
+          }
+          return property.some((prop) => {
+            const nestedProperty = getPropertyKey(prop);
+            return getProperty(nestedProperty, entity) < value;
+          });
+        });
+        break;
+      case "<=":
+        filteredEntities = options.filter((entity) => {
+          if (typeof property === "string") {
+            const nestedProperty = getPropertyKey(property);
+            return getProperty(nestedProperty, entity) <= value;
+          }
+          return property.some((prop) => {
+            const nestedProperty = getPropertyKey(prop);
+            return getProperty(nestedProperty, entity) <= value;
+          });
+        });
+        break;
+      case "is":
+        filteredEntities = options.filter((entity) => {
+          if (typeof property === "string") {
+            const nestedProperty = getPropertyKey(property);
+            const propValue = getProperty(nestedProperty, entity);
+            if (value === "null") return propValue === null || propValue === void 0;
+            if (value === "not null") return propValue !== null && propValue !== void 0;
+            return propValue === value;
+          }
+          return property.some((prop) => {
+            const nestedProperty = getPropertyKey(prop);
+            const propValue = getProperty(nestedProperty, entity);
+            if (value === "null") return propValue === null || propValue === void 0;
+            if (value === "not null") return propValue !== null && propValue !== void 0;
+            return propValue === value;
+          });
+        });
+        break;
+      case "in":
+        filteredEntities = options.filter((entity) => {
+          const valuesArray = Array.isArray(value) ? value : [value];
+          if (typeof property === "string") {
+            const nestedProperty = getPropertyKey(property);
+            const propValue = getProperty(nestedProperty, entity);
+            return valuesArray.includes(propValue);
+          }
+          return property.some((prop) => {
+            const nestedProperty = getPropertyKey(prop);
+            const propValue = getProperty(nestedProperty, entity);
+            return valuesArray.includes(propValue);
+          });
+        });
+        break;
+      case "ai_search":
+        filteredEntities = options;
+        break;
+      default:
+        console.error(`${curr.op} condition not handled`);
+        filteredEntities = [];
+        break;
+    }
+    onChange({
+      ...curr,
+      value: [
+        ...filteredEntities?.map((x) => {
+          if (curr.info.manyToOneTableInfo?.outputProperty) {
+            return x[curr.info.manyToOneTableInfo.outputProperty];
+          }
+          return x.id;
+        }) ?? []
+      ],
+      op: curr.op
+    });
+  }
+};
+var getDefaultValue = (filter) => {
+  if (filter.options && filter.propertyType !== "boolean") {
+    return filter.options[0].value;
+  } else if (filter.manyToOneTableInfo) {
+    if (filter.propertyType === "string") {
+      return "";
+    } else if (filter.propertyType === "number") {
+      return 0;
+    } else if (filter.propertyType === "boolean") {
+      return "true";
+    } else if (filter.propertyType === "date") {
+      return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    }
+    return "";
+  } else if (filter.propertyType === "string") {
+    return "";
+  } else if (filter.propertyType === "date") {
+    return (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+  } else if (filter.propertyType === "boolean") {
+    return "true";
+  } else {
+    return 0;
+  }
+};
+var getComparisonOptions = (filter) => {
+  if (filter.options) {
+    return [{ display: "=", value: "=" }];
+  }
+  switch (filter.propertyType) {
+    case "boolean":
+      return [
+        { display: "=", value: "=" },
+        { display: "is", value: "is" }
+      ];
+    case "string":
+      return [
+        { display: "=", value: "=" },
+        { display: "contains", value: "contains" },
+        { display: "ilike", value: "ilike" },
+        { display: "in", value: "in" },
+        { display: "is", value: "is" },
+        { display: "ai_search", value: "ai_search" }
+      ];
+    case "number":
+      return [
+        { display: "=", value: "=" },
+        { display: ">", value: ">" },
+        { display: "<", value: "<" },
+        { display: ">=", value: ">=" },
+        { display: "<=", value: "<=" },
+        { display: "in", value: "in" },
+        { display: "is", value: "is" }
+      ];
+    case "date":
+      return [
+        { display: "=", value: "=" },
+        { display: ">", value: ">" },
+        { display: "<", value: "<" },
+        { display: ">=", value: ">=" },
+        { display: "<=", value: "<=" },
+        { display: "is", value: "is" }
+      ];
+    default:
+      return [{ display: "=", value: "=" }];
+  }
+};
+var getDefaultCondition = (filter) => {
+  if (filter.options) return "=";
+  switch (filter.propertyType) {
+    case "boolean":
+      return "=";
+    case "string":
+      return "ilike";
+    // Case insensitive by default
+    case "number":
+      return "=";
+    case "date":
+      return "=";
+  }
+};
+var genId = () => {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, function(c) {
+    var r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+};
+var getPropertyKey = (val) => {
+  if (val.includes(".")) {
+    return val.split(".");
+  }
+  return val;
+};
+var recurseToProperty = (properties, i, entity) => {
+  if (i === properties.length) {
+    return entity;
+  }
+  return recurseToProperty(properties, i + 1, entity[properties[i]]);
+};
+var getProperty = (property, entity) => {
+  if (typeof property === "string") {
+    return entity[property];
+  }
+  return recurseToProperty(property, 0, entity);
+};
+var FilterContext = createContext2(void 0);
+var FilterProvider = ({ children, value }) => {
+  return /* @__PURE__ */ jsx2(FilterContext.Provider, { value, children });
+};
+var useFilterContext = () => {
+  const context = useContext2(FilterContext);
+  if (!context) {
+    throw new Error("useFilterContext must be used within a FilterProvider");
+  }
+  return context;
+};
+
+// src/filter-utils/useNestedFilterOptions.ts
+function useNestedFilterOptions(value, onChange) {
+  const setFilterValue = (val) => {
+    onChange({ ...value, value: val });
+  };
+  const deleteSelf = () => {
+    onChange(value.id);
+  };
+  return {
+    setFilterValue,
+    deleteSelf
+  };
+}
+export {
+  CommentContext,
+  CommentProvider,
+  FilterProvider,
+  genId,
+  getComparisonOptions,
+  getDefaultCondition,
+  getDefaultValue,
+  getProperty,
+  getPropertyKey,
+  hookOnChange,
+  recurseToProperty,
+  useComments,
+  useFilterContext,
+  useNestedFilterOptions,
+  useOrderHint_default as useOrderHint,
+  useOrderManager_default as useOrderManager,
+  usePunchListPage
+};