@pol-studios/features 1.0.0

package/dist/ordering/index.js

@@ -0,0 +1,128 @@
+// src/ordering/useOrderHint.ts
+import { isUsable } from "@pol-studios/utils";
+var useOrderHint = () => {
+  const createOrderHint = (prevOrderHint, nextOrderHint) => {
+    let newOrderHint;
+    if (isNaN(prevOrderHint)) {
+      return 1;
+    }
+    if (isUsable(nextOrderHint) === false || isNaN(nextOrderHint)) {
+      newOrderHint = prevOrderHint + 1;
+    } else if (isUsable(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 } from "react";
+import {
+  useDbRealtimeQuery,
+  useDbUpsert,
+  useSupabase
+} from "@pol-studios/db";
+import { isUsable as isUsable2 } from "@pol-studios/utils";
+var useOrderManager = (table, items, property, schema = "public") => {
+  const [managedItems, setManagedItems] = useState([]);
+  const [originalItems, setOriginalItems] = useState([]);
+  const supabase = useSupabase();
+  const upsert = useDbUpsert(schema !== "public" ? { table, schema } : table, [
+    "id"
+  ]);
+  const orderHintRequest = property ? useDbRealtimeQuery(
+    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 (isUsable2(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;
+export {
+  useOrderHint_default as useOrderHint,
+  useOrderManager_default as useOrderManager
+};

package/dist/punch-list/index.js

@@ -0,0 +1,36 @@
+// src/punch-list/usePunchListPage.ts
+import {
+  useSupabase
+} from "@pol-studios/db";
+import { useEffect, useState } from "react";
+import { useDbUpsert } from "@pol-studios/db";
+import { useAuth } from "@pol-studios/auth";
+function usePunchListPage(relation, entityId) {
+  const supabase = useSupabase();
+  const upsert = useDbUpsert("PunchListPage", ["id"]);
+  const { user } = useAuth();
+  const [punchListPageId, setPunchListPageId] = useState(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);
+    }
+  };
+  useEffect(() => {
+    handleThis();
+  }, [entityId]);
+  return punchListPageId;
+}
+export {
+  usePunchListPage
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@pol-studios/features",
+  "version": "1.0.0",
+  "description": "Feature modules for POL applications",
+  "license": "UNLICENSED",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": ["dist"],
+  "exports": {
+    ".": { "import": "./dist/index.js", "types": "./dist/index.d.ts" },
+    "./comments": { "import": "./dist/comments/index.js", "types": "./dist/comments/index.d.ts" },
+    "./ordering": { "import": "./dist/ordering/index.js", "types": "./dist/ordering/index.d.ts" },
+    "./punch-list": { "import": "./dist/punch-list/index.js", "types": "./dist/punch-list/index.d.ts" },
+    "./filter-utils": { "import": "./dist/filter-utils/index.js", "types": "./dist/filter-utils/index.d.ts" }
+  },
+  "keywords": ["features", "comments", "ordering", "punch-list"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "pnpm build"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "moment": "^2.30.1"
+  },
+  "peerDependencies": {
+    "@pol-studios/db": ">=1.0.0",
+    "@pol-studios/auth": ">=1.0.0",
+    "@pol-studios/utils": ">=1.0.0",
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "devDependencies": {
+    "@pol-studios/db": "workspace:*",
+    "@pol-studios/auth": "workspace:*",
+    "@pol-studios/utils": "workspace:*",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}