@pol-studios/db 1.0.8 → 1.0.10

package/dist/chunk-P4UZ7IXC.js

@@ -0,0 +1,42 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __require,
+  __esm,
+  __commonJS,
+  __toESM
+};
+//# sourceMappingURL=chunk-P4UZ7IXC.js.map

package/dist/chunk-P4UZ7IXC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-SEY5UO2T.js

@@ -0,0 +1,89 @@
+import {
+  useDeleteManyMutation,
+  useUpsertItem
+} from "./chunk-H6365JPC.js";
+import {
+  useSupabase
+} from "./chunk-AWFMICFV.js";
+
+// src/mutation/useBatchDelete.ts
+import { useMutation } from "@tanstack/react-query";
+function useBatchDelete(relation, primaryKeys = ["id"]) {
+  const tableName = typeof relation === "object" ? relation.table : relation;
+  const schemaName = typeof relation === "object" ? String(relation.schema) : "public";
+  const supabase = useSupabase();
+  const primaryKeysAsStrings = primaryKeys.map((k) => String(k));
+  const deleteManyMutation = useDeleteManyMutation(
+    supabase.schema(schemaName).from(tableName),
+    primaryKeysAsStrings
+  );
+  const deleteMutation = useMutation({
+    mutationFn: async (item) => {
+      if (Array.isArray(item)) {
+        const response = await deleteManyMutation.mutateAsync(item);
+        return response;
+      } else {
+        throw new Error("Item must be an array.");
+      }
+    }
+  });
+  return deleteMutation;
+}
+
+// src/mutation/useBatchUpsert.ts
+import { useMutation as useMutation2 } from "@tanstack/react-query";
+function isUsable(value) {
+  return value !== null && value !== void 0;
+}
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
+}
+function useBatchUpsert(relation, primaryKeys = ["id"], query = "*") {
+  const supabase = useSupabase();
+  const tableName = typeof relation === "object" ? relation.table : relation;
+  const schemaName = typeof relation === "object" ? String(relation.schema) : "public";
+  const upsertItem = useUpsertItem({
+    primaryKeys,
+    table: relation,
+    schema: "public"
+  });
+  const primaryKeysAsStrings = primaryKeys.map((k) => String(k));
+  async function upsertItemAction(item) {
+    let task;
+    if (Object.keys(item).length !== primaryKeys.length && primaryKeys.every((key) => key in item && isUsable(item[key]))) {
+      const updateObject = omit(item, primaryKeysAsStrings);
+      task = supabase.schema(schemaName).from(tableName).update(updateObject);
+      primaryKeys.forEach((key) => {
+        task = task.eq(String(key), item[key]);
+      });
+    } else {
+      task = supabase.schema(schemaName).from(tableName).insert(omit(item, primaryKeysAsStrings));
+    }
+    const response = await task.select(query);
+    if (response.error) {
+      throw response.error;
+    }
+    return response.data[0];
+  }
+  const updateMutation = useMutation2({
+    mutationFn: async (item) => {
+      if (Array.isArray(item)) {
+        const data = await Promise.all(item.map((x) => upsertItemAction(x)));
+        data.filter((x) => isUsable(x)).forEach((x) => upsertItem(x));
+        return data;
+      }
+      throw new Error("Item must be an array.");
+    }
+  });
+  return updateMutation;
+}
+
+export {
+  useBatchDelete,
+  useBatchUpsert
+};
+//# sourceMappingURL=chunk-SEY5UO2T.js.map

package/dist/chunk-SEY5UO2T.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/mutation/useBatchDelete.ts","../src/mutation/useBatchUpsert.ts"],"sourcesContent":["import { useMutation } from \"@tanstack/react-query\";\nimport useSupabase, { Database } from \"../client/useSupabase\";\nimport { GetResult } from \"../parser/select-query-parser\";\nimport { GenericSchema } from \"../parser/types\";\nimport {\n  useDeleteManyMutation,\n} from \"@supabase-cache-helpers/postgrest-react-query\";\n\ntype ItemType<T> = T extends Array<infer U> ? U : T;\n\nexport function useBatchDelete<\n  TableName extends string & keyof PublicSchema[\"Tables\"],\n  Table extends PublicSchema[\"Tables\"][TableName],\n  Schema extends keyof Database = \"public\",\n  PublicSchema extends GenericSchema =\n    Database[Extract<keyof Database, Schema>],\n  Query extends string = \"*\",\n  RelationName = unknown,\n  Relationships = Table extends { Relationships: infer R } ? R : unknown,\n  RowResult extends object = Omit<\n    GetResult<\n      PublicSchema,\n      Table[\"Update\"],\n      RelationName,\n      Relationships,\n      Query\n    >,\n    \"id\"\n  >,\n>(\n  relation: TableName | { table: TableName; schema: Schema },\n  primaryKeys: (keyof ItemType<RowResult> & string)[] = [\"id\" as any],\n) {\n  const tableName = typeof relation === \"object\" ? relation.table : relation;\n  const schemaName: string = typeof relation === \"object\"\n    ? String(relation.schema)\n    : \"public\";\n\n  const supabase = useSupabase();\n  const primaryKeysAsStrings = primaryKeys.map((k) => String(k)) as string[];\n  const deleteManyMutation = useDeleteManyMutation(\n    supabase.schema(schemaName as \"public\").from(tableName as any) as any,\n    primaryKeysAsStrings as any,\n  );\n\n  const deleteMutation = useMutation<\n    RowResult | null,\n    Error,\n    RowResult | RowResult[]\n  >({\n    mutationFn: async (item) => {\n      if (Array.isArray(item)) {\n        const response = await deleteManyMutation.mutateAsync(item);\n        return response as any;\n      } else {\n        throw new Error(\"Item must be an array.\");\n      }\n    },\n  });\n\n  return deleteMutation;\n}\n","import { useMutation } from \"@tanstack/react-query\";\nimport useSupabase, { Database } from \"../client/useSupabase\";\nimport { useUpsertItem } from \"@supabase-cache-helpers/postgrest-react-query\";\nimport { GetResult } from \"../parser/select-query-parser\";\nimport { GenericSchema } from \"../parser/types\";\n\nfunction isUsable<T>(value: T | null | undefined): value is T {\n  return value !== null && value !== undefined;\n}\n\nfunction omit<T extends Record<string, any>, K extends keyof T>(\n  obj: T,\n  keys: K[]\n): Omit<T, K> {\n  const result = { ...obj };\n  for (const key of keys) {\n    delete result[key];\n  }\n  return result;\n}\n\ntype ItemType<T> = T extends Array<infer U> ? U : T;\n\nexport function useBatchUpsert<\n  TableName extends string & keyof PublicSchema[\"Tables\"],\n  Table extends PublicSchema[\"Tables\"][TableName],\n  Schema extends keyof Database = \"public\",\n  PublicSchema extends GenericSchema =\n    Database[Extract<keyof Database, Schema>],\n  Query extends string = \"*\",\n  RelationName = unknown,\n  Relationships = Table extends { Relationships: infer R } ? R : unknown,\n  RowResult extends object = GetResult<\n    PublicSchema,\n    Table[\"Row\"],\n    RelationName,\n    Relationships,\n    Query\n  >,\n  ResultInsert extends object = GetResult<\n    PublicSchema,\n    Table[\"Insert\"],\n    RelationName,\n    Relationships,\n    Query\n  >,\n  ResultUpdate extends object =\n    & Omit<\n      GetResult<\n        PublicSchema,\n        Table[\"Update\"],\n        RelationName,\n        Relationships,\n        Query\n      >,\n      \"id\"\n    >\n    & { id: any },\n>(\n  relation: TableName | { table: TableName; schema: Schema },\n  primaryKeys: (keyof (ItemType<RowResult> | any) & string)[] = [\"id\"],\n  query: string = \"*\",\n) {\n  const supabase = useSupabase();\n  const tableName = typeof relation === \"object\" ? relation.table : relation;\n  const schemaName: string = typeof relation === \"object\"\n    ? String(relation.schema)\n    : \"public\";\n\n  const upsertItem = useUpsertItem({\n    primaryKeys: primaryKeys,\n    table: relation as any,\n    schema: \"public\",\n  });\n\n  const primaryKeysAsStrings = primaryKeys.map((k) => String(k)) as string[];\n\n  async function upsertItemAction(item: any) {\n    let task: any;\n\n    if (\n      Object.keys(item).length !== primaryKeys.length &&\n      primaryKeys.every((key) => key in item && isUsable(item[key]))\n    ) {\n      const updateObject = omit(item as any, primaryKeysAsStrings as any) as any;\n      task = supabase\n        .schema(schemaName as \"public\")\n        .from(tableName as any).update(updateObject);\n\n      primaryKeys.forEach((key) => {\n        task = task.eq(String(key), item[key]);\n      });\n    } else {\n      task = supabase\n        .schema(schemaName as \"public\")\n        .from(tableName as any)\n        .insert(omit(item as any, primaryKeysAsStrings as any) as any);\n    }\n\n    const response = await task.select(query);\n    if (response.error) {\n      throw response.error;\n    }\n    return response.data[0];\n  }\n\n  const updateMutation = useMutation<\n    (RowResult[] | null),\n    Error,\n    (ResultUpdate | ResultInsert)[]\n  >({\n    mutationFn: async (item) => {\n      if (Array.isArray(item)) {\n        const data = await Promise.all(item.map((x) => upsertItemAction(x)));\n        data.filter((x) => isUsable(x)).forEach((x) => upsertItem(x as any));\n        return data as RowResult[];\n      }\n      throw new Error(\"Item must be an array.\");\n    },\n  });\n\n  return updateMutation;\n}\n"],"mappings":";;;;;;;;;AAAA,SAAS,mBAAmB;AAUrB,SAAS,eAoBd,UACA,cAAsD,CAAC,IAAW,GAClE;AACA,QAAM,YAAY,OAAO,aAAa,WAAW,SAAS,QAAQ;AAClE,QAAM,aAAqB,OAAO,aAAa,WAC3C,OAAO,SAAS,MAAM,IACtB;AAEJ,QAAM,WAAW,YAAY;AAC7B,QAAM,uBAAuB,YAAY,IAAI,CAAC,MAAM,OAAO,CAAC,CAAC;AAC7D,QAAM,qBAAqB;AAAA,IACzB,SAAS,OAAO,UAAsB,EAAE,KAAK,SAAgB;AAAA,IAC7D;AAAA,EACF;AAEA,QAAM,iBAAiB,YAIrB;AAAA,IACA,YAAY,OAAO,SAAS;AAC1B,UAAI,MAAM,QAAQ,IAAI,GAAG;AACvB,cAAM,WAAW,MAAM,mBAAmB,YAAY,IAAI;AAC1D,eAAO;AAAA,MACT,OAAO;AACL,cAAM,IAAI,MAAM,wBAAwB;AAAA,MAC1C;AAAA,IACF;AAAA,EACF,CAAC;AAED,SAAO;AACT;;;AC7DA,SAAS,eAAAA,oBAAmB;AAM5B,SAAS,SAAY,OAAyC;AAC5D,SAAO,UAAU,QAAQ,UAAU;AACrC;AAEA,SAAS,KACP,KACA,MACY;AACZ,QAAM,SAAS,EAAE,GAAG,IAAI;AACxB,aAAW,OAAO,MAAM;AACtB,WAAO,OAAO,GAAG;AAAA,EACnB;AACA,SAAO;AACT;AAIO,SAAS,eAoCd,UACA,cAA8D,CAAC,IAAI,GACnE,QAAgB,KAChB;AACA,QAAM,WAAW,YAAY;AAC7B,QAAM,YAAY,OAAO,aAAa,WAAW,SAAS,QAAQ;AAClE,QAAM,aAAqB,OAAO,aAAa,WAC3C,OAAO,SAAS,MAAM,IACtB;AAEJ,QAAM,aAAa,cAAc;AAAA,IAC/B;AAAA,IACA,OAAO;AAAA,IACP,QAAQ;AAAA,EACV,CAAC;AAED,QAAM,uBAAuB,YAAY,IAAI,CAAC,MAAM,OAAO,CAAC,CAAC;AAE7D,iBAAe,iBAAiB,MAAW;AACzC,QAAI;AAEJ,QACE,OAAO,KAAK,IAAI,EAAE,WAAW,YAAY,UACzC,YAAY,MAAM,CAAC,QAAQ,OAAO,QAAQ,SAAS,KAAK,GAAG,CAAC,CAAC,GAC7D;AACA,YAAM,eAAe,KAAK,MAAa,oBAA2B;AAClE,aAAO,SACJ,OAAO,UAAsB,EAC7B,KAAK,SAAgB,EAAE,OAAO,YAAY;AAE7C,kBAAY,QAAQ,CAAC,QAAQ;AAC3B,eAAO,KAAK,GAAG,OAAO,GAAG,GAAG,KAAK,GAAG,CAAC;AAAA,MACvC,CAAC;AAAA,IACH,OAAO;AACL,aAAO,SACJ,OAAO,UAAsB,EAC7B,KAAK,SAAgB,EACrB,OAAO,KAAK,MAAa,oBAA2B,CAAQ;AAAA,IACjE;AAEA,UAAM,WAAW,MAAM,KAAK,OAAO,KAAK;AACxC,QAAI,SAAS,OAAO;AAClB,YAAM,SAAS;AAAA,IACjB;AACA,WAAO,SAAS,KAAK,CAAC;AAAA,EACxB;AAEA,QAAM,iBAAiBC,aAIrB;AAAA,IACA,YAAY,OAAO,SAAS;AAC1B,UAAI,MAAM,QAAQ,IAAI,GAAG;AACvB,cAAM,OAAO,MAAM,QAAQ,IAAI,KAAK,IAAI,CAAC,MAAM,iBAAiB,CAAC,CAAC,CAAC;AACnE,aAAK,OAAO,CAAC,MAAM,SAAS,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,WAAW,CAAQ,CAAC;AACnE,eAAO;AAAA,MACT;AACA,YAAM,IAAI,MAAM,wBAAwB;AAAA,IAC1C;AAAA,EACF,CAAC;AAED,SAAO;AACT;","names":["useMutation","useMutation"]}

package/dist/chunk-USJYMRUO.js

@@ -0,0 +1,86 @@
+import {
+  isUsable
+} from "./chunk-O3K7R32P.js";
+
+// src/auth/guards/hasAccess.ts
+function hasAccess(accessKeys, key, options) {
+  if (options?.isArchived || options?.isSuspended) {
+    return false;
+  }
+  if (isUsable(accessKeys) === false) {
+    return false;
+  }
+  if (accessKeys.includes("owner")) {
+    return true;
+  }
+  if (accessKeys.includes(key)) {
+    return true;
+  }
+  if (isUsable(key) === false) {
+    return true;
+  }
+  return false;
+}
+function hasAnyAccess(accessKeys, keys, options) {
+  return keys.some((key) => hasAccess(accessKeys, key, options));
+}
+function hasAllAccess(accessKeys, keys, options) {
+  return keys.every((key) => hasAccess(accessKeys, key, options));
+}
+
+// src/auth/guards/hasEntityAccess.ts
+function hasEntityAccess(permission, action, options) {
+  if (options?.isArchived || options?.isSuspended) {
+    return false;
+  }
+  const accessKeys = options?.accessKeys;
+  if (isUsable(accessKeys) && accessKeys.includes("owner")) {
+    return true;
+  }
+  if (!permission) {
+    return false;
+  }
+  if (permission.isLoading) {
+    return false;
+  }
+  switch (action) {
+    case "view":
+      return permission.canView;
+    case "adminView":
+      return permission.canAdminView;
+    case "edit":
+      return permission.canEdit;
+    case "create":
+      return permission.canCreate;
+    case "delete":
+      return permission.canDelete;
+    case "share":
+      return permission.canShare;
+    default:
+      return false;
+  }
+}
+function hasAnyEntityAccess(permission, actions, options) {
+  return actions.some((action) => hasEntityAccess(permission, action, options));
+}
+function hasAllEntityAccess(permission, actions, options) {
+  return actions.every((action) => hasEntityAccess(permission, action, options));
+}
+function isEntityAccessDenied(permission) {
+  return permission?.isDenied === true;
+}
+function isPermissionLoaded(permission) {
+  return permission !== null && permission !== void 0 && !permission.isLoading;
+}
+
+export {
+  hasAccess,
+  hasAnyAccess,
+  hasAllAccess,
+  hasEntityAccess,
+  hasAnyEntityAccess,
+  hasAllEntityAccess,
+  isEntityAccessDenied,
+  isPermissionLoaded
+};
+//# sourceMappingURL=chunk-USJYMRUO.js.map

package/dist/chunk-USJYMRUO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/auth/guards/hasAccess.ts","../src/auth/guards/hasEntityAccess.ts"],"sourcesContent":["import { isUsable } from \"@pol-studios/utils\";\n\n/**\n * Check if a user has access to a specific permission key.\n * Owners bypass all permission checks.\n *\n * @param accessKeys - Array of access keys the user has\n * @param key - The access key to check for\n * @param options - Additional options for the check\n * @param options.isArchived - Whether the user is archived\n * @param options.isSuspended - Whether the user is suspended\n * @returns boolean - true if user has the specified access\n *\n * @example\n * ```ts\n * // Basic usage\n * const canAccess = hasAccess(['admin', 'viewer'], 'admin'); // true\n * const cannotAccess = hasAccess(['viewer'], 'admin'); // false\n *\n * // Owner bypasses all checks\n * const ownerAccess = hasAccess(['owner'], 'any-key'); // true\n *\n * // Empty key always returns true (no permission required)\n * const noKeyRequired = hasAccess(['viewer'], ''); // true\n *\n * // Archived/suspended users have no access\n * const archivedUser = hasAccess(['admin'], 'admin', { isArchived: true }); // false\n * ```\n */\nexport function hasAccess(\n  accessKeys: string[] | undefined | null,\n  key: string,\n  options?: {\n    isArchived?: boolean;\n    isSuspended?: boolean;\n  }\n): boolean {\n  // Archived/suspended users have no access\n  if (options?.isArchived || options?.isSuspended) {\n    return false;\n  }\n\n  // No access keys means no access\n  if (isUsable(accessKeys) === false) {\n    return false;\n  }\n\n  // Owners bypass all permission checks\n  if (accessKeys.includes(\"owner\")) {\n    return true;\n  }\n\n  // Check if the specific key is present\n  if (accessKeys.includes(key)) {\n    return true;\n  }\n\n  // Empty/undefined key means no specific permission required\n  if (isUsable(key) === false) {\n    return true;\n  }\n\n  return false;\n}\n\n/**\n * Check if a user has any of the specified access keys.\n *\n * @param accessKeys - Array of access keys the user has\n * @param keys - Array of access keys to check for (OR logic)\n * @param options - Additional options for the check\n * @returns boolean - true if user has any of the specified keys\n *\n * @example\n * ```ts\n * const hasAny = hasAnyAccess(['viewer'], ['admin', 'editor', 'viewer']); // true\n * const hasNone = hasAnyAccess(['viewer'], ['admin', 'editor']); // false\n * ```\n */\nexport function hasAnyAccess(\n  accessKeys: string[] | undefined | null,\n  keys: string[],\n  options?: {\n    isArchived?: boolean;\n    isSuspended?: boolean;\n  }\n): boolean {\n  // Check each key, return true if any match\n  return keys.some((key) => hasAccess(accessKeys, key, options));\n}\n\n/**\n * Check if a user has all of the specified access keys.\n *\n * @param accessKeys - Array of access keys the user has\n * @param keys - Array of access keys to check for (AND logic)\n * @param options - Additional options for the check\n * @returns boolean - true if user has all of the specified keys\n *\n * @example\n * ```ts\n * const hasAll = hasAllAccess(['admin', 'editor'], ['admin', 'editor']); // true\n * const hasPartial = hasAllAccess(['admin'], ['admin', 'editor']); // false\n * ```\n */\nexport function hasAllAccess(\n  accessKeys: string[] | undefined | null,\n  keys: string[],\n  options?: {\n    isArchived?: boolean;\n    isSuspended?: boolean;\n  }\n): boolean {\n  // Check each key, return true only if all match\n  return keys.every((key) => hasAccess(accessKeys, key, options));\n}\n","import { isUsable } from \"@pol-studios/utils\";\nimport { EntityType, EntityAction, EntityPermissionCheck } from \"../types/EntityPermissions\";\n\n/**\n * Check if a user has entity-level access based on permission check result.\n * Owners (users with 'owner' access key) bypass entity permissions entirely.\n *\n * @param permission - The permission check result from getPermission/usePermission\n * @param action - The action to check for\n * @param options - Additional options for the check\n * @param options.accessKeys - User's access keys (for owner check)\n * @param options.isArchived - Whether the user is archived\n * @param options.isSuspended - Whether the user is suspended\n * @returns boolean - true if user has permission for the action\n *\n * @example\n * ```ts\n * // Basic usage\n * const permission = await getPermission('Project', 123);\n * const canEdit = hasEntityAccess(permission, 'edit');\n *\n * // With owner bypass\n * const canEditAsOwner = hasEntityAccess(permission, 'edit', {\n *   accessKeys: ['owner'],\n * }); // true, owners bypass all checks\n *\n * // Check loading state\n * if (permission.isLoading) {\n *   return false; // Wait for permission to load\n * }\n * ```\n */\nexport function hasEntityAccess(\n  permission: EntityPermissionCheck | null | undefined,\n  action: EntityAction,\n  options?: {\n    accessKeys?: string[] | null;\n    isArchived?: boolean;\n    isSuspended?: boolean;\n  }\n): boolean {\n  // Archived/suspended users have no entity access\n  if (options?.isArchived || options?.isSuspended) {\n    return false;\n  }\n\n  // Owners bypass all entity permission checks\n  const accessKeys = options?.accessKeys;\n  if (isUsable(accessKeys) && accessKeys.includes(\"owner\")) {\n    return true;\n  }\n\n  // No permission data means no access\n  if (!permission) {\n    return false;\n  }\n\n  // Still loading means no access (yet)\n  if (permission.isLoading) {\n    return false;\n  }\n\n  // Check the specific action\n  switch (action) {\n    case \"view\":\n      return permission.canView;\n    case \"adminView\":\n      return permission.canAdminView;\n    case \"edit\":\n      return permission.canEdit;\n    case \"create\":\n      return permission.canCreate;\n    case \"delete\":\n      return permission.canDelete;\n    case \"share\":\n      return permission.canShare;\n    default:\n      return false;\n  }\n}\n\n/**\n * Check if a user has any of the specified entity actions.\n *\n * @param permission - The permission check result\n * @param actions - Array of actions to check for (OR logic)\n * @param options - Additional options for the check\n * @returns boolean - true if user has permission for any of the actions\n *\n * @example\n * ```ts\n * const canEditOrDelete = hasAnyEntityAccess(permission, ['edit', 'delete']);\n * ```\n */\nexport function hasAnyEntityAccess(\n  permission: EntityPermissionCheck | null | undefined,\n  actions: EntityAction[],\n  options?: {\n    accessKeys?: string[] | null;\n    isArchived?: boolean;\n    isSuspended?: boolean;\n  }\n): boolean {\n  return actions.some((action) => hasEntityAccess(permission, action, options));\n}\n\n/**\n * Check if a user has all of the specified entity actions.\n *\n * @param permission - The permission check result\n * @param actions - Array of actions to check for (AND logic)\n * @param options - Additional options for the check\n * @returns boolean - true if user has permission for all of the actions\n *\n * @example\n * ```ts\n * // Check if user can edit AND delete (admin-like permissions)\n * const isAdmin = hasAllEntityAccess(permission, ['edit', 'delete', 'share']);\n * ```\n */\nexport function hasAllEntityAccess(\n  permission: EntityPermissionCheck | null | undefined,\n  actions: EntityAction[],\n  options?: {\n    accessKeys?: string[] | null;\n    isArchived?: boolean;\n    isSuspended?: boolean;\n  }\n): boolean {\n  return actions.every((action) => hasEntityAccess(permission, action, options));\n}\n\n/**\n * Check if entity access was explicitly denied.\n * Useful for distinguishing between \"no permission\" and \"explicitly blocked\".\n *\n * @param permission - The permission check result\n * @returns boolean - true if access was explicitly denied\n *\n * @example\n * ```ts\n * const permission = await getPermission('Project', 123);\n * if (isEntityAccessDenied(permission)) {\n *   showBlockedMessage('You have been explicitly denied access to this project');\n * }\n * ```\n */\nexport function isEntityAccessDenied(\n  permission: EntityPermissionCheck | null | undefined\n): boolean {\n  return permission?.isDenied === true;\n}\n\n/**\n * Type guard to check if permission data is loaded and available.\n *\n * @param permission - The permission check result\n * @returns boolean - true if permission data is loaded\n *\n * @example\n * ```ts\n * const permission = usePermission('Project', projectId);\n *\n * if (!isPermissionLoaded(permission)) {\n *   return <Spinner />;\n * }\n *\n * // TypeScript knows permission is fully loaded here\n * return permission.canEdit ? <Editor /> : <Viewer />;\n * ```\n */\nexport function isPermissionLoaded(\n  permission: EntityPermissionCheck | null | undefined\n): permission is EntityPermissionCheck & { isLoading: false } {\n  return permission !== null && permission !== undefined && !permission.isLoading;\n}\n"],"mappings":";;;;;AA6BO,SAAS,UACd,YACA,KACA,SAIS;AAET,MAAI,SAAS,cAAc,SAAS,aAAa;AAC/C,WAAO;AAAA,EACT;AAGA,MAAI,SAAS,UAAU,MAAM,OAAO;AAClC,WAAO;AAAA,EACT;AAGA,MAAI,WAAW,SAAS,OAAO,GAAG;AAChC,WAAO;AAAA,EACT;AAGA,MAAI,WAAW,SAAS,GAAG,GAAG;AAC5B,WAAO;AAAA,EACT;AAGA,MAAI,SAAS,GAAG,MAAM,OAAO;AAC3B,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAgBO,SAAS,aACd,YACA,MACA,SAIS;AAET,SAAO,KAAK,KAAK,CAAC,QAAQ,UAAU,YAAY,KAAK,OAAO,CAAC;AAC/D;AAgBO,SAAS,aACd,YACA,MACA,SAIS;AAET,SAAO,KAAK,MAAM,CAAC,QAAQ,UAAU,YAAY,KAAK,OAAO,CAAC;AAChE;;;ACnFO,SAAS,gBACd,YACA,QACA,SAKS;AAET,MAAI,SAAS,cAAc,SAAS,aAAa;AAC/C,WAAO;AAAA,EACT;AAGA,QAAM,aAAa,SAAS;AAC5B,MAAI,SAAS,UAAU,KAAK,WAAW,SAAS,OAAO,GAAG;AACxD,WAAO;AAAA,EACT;AAGA,MAAI,CAAC,YAAY;AACf,WAAO;AAAA,EACT;AAGA,MAAI,WAAW,WAAW;AACxB,WAAO;AAAA,EACT;AAGA,UAAQ,QAAQ;AAAA,IACd,KAAK;AACH,aAAO,WAAW;AAAA,IACpB,KAAK;AACH,aAAO,WAAW;AAAA,IACpB,KAAK;AACH,aAAO,WAAW;AAAA,IACpB,KAAK;AACH,aAAO,WAAW;AAAA,IACpB,KAAK;AACH,aAAO,WAAW;AAAA,IACpB,KAAK;AACH,aAAO,WAAW;AAAA,IACpB;AACE,aAAO;AAAA,EACX;AACF;AAeO,SAAS,mBACd,YACA,SACA,SAKS;AACT,SAAO,QAAQ,KAAK,CAAC,WAAW,gBAAgB,YAAY,QAAQ,OAAO,CAAC;AAC9E;AAgBO,SAAS,mBACd,YACA,SACA,SAKS;AACT,SAAO,QAAQ,MAAM,CAAC,WAAW,gBAAgB,YAAY,QAAQ,OAAO,CAAC;AAC/E;AAiBO,SAAS,qBACd,YACS;AACT,SAAO,YAAY,aAAa;AAClC;AAoBO,SAAS,mBACd,YAC4D;AAC5D,SAAO,eAAe,QAAQ,eAAe,UAAa,CAAC,WAAW;AACxE;","names":[]}

package/dist/chunk-XX3IWSPM.js

@@ -0,0 +1,189 @@
+import {
+  useDataLayer
+} from "./chunk-3M2U6TXH.js";
+
+// src/hooks/useSyncStatus.ts
+import { useState, useEffect } from "react";
+var defaultSyncStatus = {
+  isConnected: true,
+  // Supabase-only mode is always "connected" when online
+  isSyncing: false,
+  lastSyncedAt: null,
+  pendingUploads: 0,
+  error: null
+};
+function useSyncStatus() {
+  const { syncStatus, status, powerSync } = useDataLayer();
+  const [currentStatus, setCurrentStatus] = useState(syncStatus);
+  useEffect(() => {
+    if (powerSync && status.currentBackend === "powersync") {
+      setCurrentStatus(syncStatus);
+    } else {
+      setCurrentStatus({
+        ...defaultSyncStatus,
+        isConnected: status.isOnline
+      });
+    }
+  }, [syncStatus, status.currentBackend, status.isOnline, powerSync]);
+  return currentStatus;
+}
+
+// src/hooks/useSyncControl.ts
+import { useMemo } from "react";
+function useSyncControl() {
+  const { syncControl, status, powerSync } = useDataLayer();
+  const noOpControls = useMemo(
+    () => ({
+      triggerSync: async () => {
+        console.warn(
+          "[useSyncControl] triggerSync called but PowerSync is not available"
+        );
+      },
+      startLiveSync: async () => {
+        console.warn(
+          "[useSyncControl] startLiveSync called but PowerSync is not available"
+        );
+      },
+      stopLiveSync: () => {
+        console.warn(
+          "[useSyncControl] stopLiveSync called but PowerSync is not available"
+        );
+      },
+      setScope: async (_scopeName, _values) => {
+        console.warn(
+          "[useSyncControl] setScope called but PowerSync is not available"
+        );
+      }
+    }),
+    []
+  );
+  const controls = useMemo(() => {
+    if (powerSync && status.currentBackend === "powersync") {
+      return syncControl;
+    }
+    return noOpControls;
+  }, [powerSync, status.currentBackend, syncControl, noOpControls]);
+  return controls;
+}
+
+// src/hooks/useOnlineStatus.ts
+import { useState as useState2, useEffect as useEffect2 } from "react";
+
+// src/utils/network.ts
+var netInfoModule = null;
+var netInfoChecked = false;
+function isReactNative() {
+  return typeof navigator !== "undefined" && navigator.product === "ReactNative";
+}
+async function getNetInfo() {
+  if (netInfoChecked) {
+    return netInfoModule;
+  }
+  netInfoChecked = true;
+  if (!isReactNative()) {
+    return null;
+  }
+  try {
+    const module = await import("@react-native-community/netinfo");
+    netInfoModule = module.default || module;
+    return netInfoModule;
+  } catch {
+    return null;
+  }
+}
+async function getOnlineStatus() {
+  const netInfo = await getNetInfo();
+  if (netInfo) {
+    const state = await netInfo.fetch();
+    return state.isConnected ?? true;
+  }
+  if (typeof navigator !== "undefined" && "onLine" in navigator) {
+    return navigator.onLine;
+  }
+  return true;
+}
+function getOnlineStatusSync() {
+  if (typeof window !== "undefined" && typeof navigator !== "undefined") {
+    return navigator.onLine;
+  }
+  return true;
+}
+function subscribeToNetworkChanges(callback) {
+  if (isReactNative()) {
+    let unsubscribe = null;
+    getNetInfo().then((netInfo) => {
+      if (netInfo) {
+        unsubscribe = netInfo.addEventListener((state) => {
+          callback(state.isConnected ?? true);
+        });
+      }
+    });
+    return () => {
+      if (unsubscribe) {
+        unsubscribe();
+      }
+    };
+  }
+  const isBrowser = typeof window !== "undefined" && typeof window.addEventListener === "function";
+  if (isBrowser) {
+    const handleOnline = () => callback(true);
+    const handleOffline = () => callback(false);
+    window.addEventListener("online", handleOnline);
+    window.addEventListener("offline", handleOffline);
+    return () => {
+      window.removeEventListener("online", handleOnline);
+      window.removeEventListener("offline", handleOffline);
+    };
+  }
+  return () => {
+  };
+}
+async function initializeNetworkMonitoring() {
+  await getNetInfo();
+}
+
+// src/hooks/useOnlineStatus.ts
+function useOnlineStatus() {
+  const { status, powerSync } = useDataLayer();
+  const [onlineStatus, setOnlineStatus] = useState2({
+    isOnline: status.isOnline,
+    isConnected: status.powerSyncStatus === "available",
+    backend: status.currentBackend
+  });
+  useEffect2(() => {
+    setOnlineStatus({
+      isOnline: status.isOnline,
+      isConnected: powerSync !== null && status.powerSyncStatus === "available",
+      backend: status.currentBackend
+    });
+  }, [status.isOnline, status.powerSyncStatus, status.currentBackend, powerSync]);
+  useEffect2(() => {
+    getOnlineStatus().then((isOnline) => {
+      setOnlineStatus((prev) => {
+        if (prev.isOnline !== isOnline) {
+          return { ...prev, isOnline };
+        }
+        return prev;
+      });
+    });
+  }, []);
+  useEffect2(() => {
+    const unsubscribe = subscribeToNetworkChanges((isOnline) => {
+      setOnlineStatus((prev) => ({ ...prev, isOnline }));
+    });
+    return unsubscribe;
+  }, []);
+  return onlineStatus;
+}
+
+export {
+  useSyncStatus,
+  useSyncControl,
+  isReactNative,
+  getOnlineStatus,
+  getOnlineStatusSync,
+  subscribeToNetworkChanges,
+  initializeNetworkMonitoring,
+  useOnlineStatus
+};
+//# sourceMappingURL=chunk-XX3IWSPM.js.map

package/dist/chunk-XX3IWSPM.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/hooks/useSyncStatus.ts","../src/hooks/useSyncControl.ts","../src/hooks/useOnlineStatus.ts","../src/utils/network.ts"],"sourcesContent":["/**\n * V3 useSyncStatus Hook\n *\n * Provides sync status information from the data layer.\n * Returns default \"always synced\" status when PowerSync is not available.\n */\n\nimport { useState, useEffect } from \"react\";\nimport { useDataLayer } from \"./useDataLayer\";\nimport type { SyncStatus } from \"../core/types\";\n\n/**\n * Default sync status when PowerSync is not available\n */\nconst defaultSyncStatus: SyncStatus = {\n  isConnected: true, // Supabase-only mode is always \"connected\" when online\n  isSyncing: false,\n  lastSyncedAt: null,\n  pendingUploads: 0,\n  error: null,\n};\n\n/**\n * Hook to get the current sync status\n *\n * When PowerSync is not available, returns a default \"always synced\" status.\n *\n * @example\n * const { isSyncing, pendingUploads, isConnected } = useSyncStatus();\n *\n * if (pendingUploads > 0) {\n *   console.log(`${pendingUploads} changes waiting to sync`);\n * }\n */\nexport function useSyncStatus(): SyncStatus {\n  const { syncStatus, status, powerSync } = useDataLayer();\n  const [currentStatus, setCurrentStatus] = useState<SyncStatus>(syncStatus);\n\n  // Update status when context changes\n  useEffect(() => {\n    // If PowerSync is available, use actual sync status\n    if (powerSync && status.currentBackend === \"powersync\") {\n      setCurrentStatus(syncStatus);\n    } else {\n      // Supabase-only mode - return default status based on online state\n      setCurrentStatus({\n        ...defaultSyncStatus,\n        isConnected: status.isOnline,\n      });\n    }\n  }, [syncStatus, status.currentBackend, status.isOnline, powerSync]);\n\n  return currentStatus;\n}\n\nexport default useSyncStatus;\n","/**\n * V3 useSyncControl Hook\n *\n * Provides sync control functions from the data layer.\n * Returns no-op functions when PowerSync is not available.\n */\n\nimport { useMemo } from \"react\";\nimport { useDataLayer } from \"./useDataLayer\";\nimport type { SyncControl } from \"../core/types\";\n\n/**\n * Hook to get sync controls for PowerSync\n *\n * When PowerSync is not available, all methods are no-ops that log a warning.\n *\n * @example\n * const { triggerSync, startLiveSync, stopLiveSync } = useSyncControl();\n *\n * // Manually trigger a sync\n * await triggerSync();\n *\n * // Start/stop live sync\n * await startLiveSync();\n * stopLiveSync();\n */\nexport function useSyncControl(): SyncControl {\n  const { syncControl, status, powerSync } = useDataLayer();\n\n  // Create no-op controls for when PowerSync is not available\n  const noOpControls = useMemo<SyncControl>(\n    () => ({\n      triggerSync: async () => {\n        console.warn(\n          \"[useSyncControl] triggerSync called but PowerSync is not available\"\n        );\n      },\n      startLiveSync: async () => {\n        console.warn(\n          \"[useSyncControl] startLiveSync called but PowerSync is not available\"\n        );\n      },\n      stopLiveSync: () => {\n        console.warn(\n          \"[useSyncControl] stopLiveSync called but PowerSync is not available\"\n        );\n      },\n      setScope: async (_scopeName: string, _values: string[]) => {\n        console.warn(\n          \"[useSyncControl] setScope called but PowerSync is not available\"\n        );\n      },\n    }),\n    []\n  );\n\n  // Return actual controls if PowerSync is available, otherwise no-ops\n  const controls = useMemo<SyncControl>(() => {\n    if (powerSync && status.currentBackend === \"powersync\") {\n      return syncControl;\n    }\n    return noOpControls;\n  }, [powerSync, status.currentBackend, syncControl, noOpControls]);\n\n  return controls;\n}\n\nexport default useSyncControl;\n","/**\n * V3 useOnlineStatus Hook\n *\n * Provides online/connection status information.\n * Combines data layer status with platform-specific online/offline events.\n * Works on both web (browser events) and React Native (NetInfo).\n */\n\nimport { useState, useEffect } from \"react\";\nimport { useDataLayer } from \"./useDataLayer\";\nimport { subscribeToNetworkChanges, getOnlineStatus } from \"../utils/network\";\n\n/**\n * Online status information\n */\nexport interface OnlineStatus {\n  /** Whether the device has network connectivity */\n  isOnline: boolean;\n  /** Whether PowerSync is connected (false if using Supabase-only) */\n  isConnected: boolean;\n  /** Current backend being used */\n  backend: \"powersync\" | \"supabase\" | null;\n}\n\n/**\n * Hook to get online/connection status\n *\n * @example\n * const { isOnline, isConnected, backend } = useOnlineStatus();\n *\n * if (!isOnline) {\n *   return <OfflineBanner />;\n * }\n */\nexport function useOnlineStatus(): OnlineStatus {\n  const { status, powerSync } = useDataLayer();\n\n  const [onlineStatus, setOnlineStatus] = useState<OnlineStatus>({\n    isOnline: status.isOnline,\n    isConnected: status.powerSyncStatus === \"available\",\n    backend: status.currentBackend,\n  });\n\n  // Update status when context changes\n  useEffect(() => {\n    setOnlineStatus({\n      isOnline: status.isOnline,\n      isConnected:\n        powerSync !== null && status.powerSyncStatus === \"available\",\n      backend: status.currentBackend,\n    });\n  }, [status.isOnline, status.powerSyncStatus, status.currentBackend, powerSync]);\n\n  // Check actual network status on mount (especially important for React Native\n  // where the auto-detector doesn't check NetInfo and always returns true)\n  useEffect(() => {\n    getOnlineStatus().then((isOnline) => {\n      setOnlineStatus((prev) => {\n        if (prev.isOnline !== isOnline) {\n          return { ...prev, isOnline };\n        }\n        return prev;\n      });\n    });\n  }, []);\n\n  // Listen to platform-specific online/offline events for immediate updates\n  // Works on both web (browser events) and React Native (NetInfo)\n  useEffect(() => {\n    const unsubscribe = subscribeToNetworkChanges((isOnline) => {\n      setOnlineStatus((prev) => ({ ...prev, isOnline }));\n    });\n\n    return unsubscribe;\n  }, []);\n\n  return onlineStatus;\n}\n\nexport default useOnlineStatus;\n","/**\n * Platform-aware network status utility\n *\n * Provides unified network connectivity detection for both web (browser)\n * and React Native environments.\n *\n * - On React Native: Uses @react-native-community/netinfo\n * - On Web: Uses navigator.onLine and window online/offline events\n */\n\n// Type for NetInfo to avoid hard dependency\ninterface NetInfoState {\n  isConnected: boolean | null;\n  isInternetReachable: boolean | null;\n}\n\ntype NetInfoSubscription = () => void;\n\ninterface NetInfoModule {\n  fetch: () => Promise<NetInfoState>;\n  addEventListener: (\n    callback: (state: NetInfoState) => void\n  ) => NetInfoSubscription;\n}\n\n// Cached NetInfo module reference\nlet netInfoModule: NetInfoModule | null = null;\nlet netInfoChecked = false;\n\n/**\n * Check if we're running in React Native environment\n */\nexport function isReactNative(): boolean {\n  return (\n    typeof navigator !== \"undefined\" && navigator.product === \"ReactNative\"\n  );\n}\n\n/**\n * Try to load NetInfo module (React Native only)\n * Returns null if not available\n */\nasync function getNetInfo(): Promise<NetInfoModule | null> {\n  if (netInfoChecked) {\n    return netInfoModule;\n  }\n\n  netInfoChecked = true;\n\n  if (!isReactNative()) {\n    return null;\n  }\n\n  try {\n    // Dynamic import to avoid bundling issues on web\n    const module = await import(\"@react-native-community/netinfo\");\n    netInfoModule = module.default || module;\n    return netInfoModule;\n  } catch {\n    // NetInfo not available\n    return null;\n  }\n}\n\n/**\n * Get current online status\n *\n * @returns Promise resolving to true if online, false if offline\n */\nexport async function getOnlineStatus(): Promise<boolean> {\n  const netInfo = await getNetInfo();\n\n  if (netInfo) {\n    // React Native with NetInfo\n    const state = await netInfo.fetch();\n    return state.isConnected ?? true;\n  }\n\n  // Browser environment\n  if (typeof navigator !== \"undefined\" && \"onLine\" in navigator) {\n    return navigator.onLine;\n  }\n\n  // SSR or unknown environment - assume online\n  return true;\n}\n\n/**\n * Get current online status synchronously (browser only, RN returns cached/default)\n * Use getOnlineStatus() for accurate cross-platform results\n *\n * @returns true if online (or unknown), false if offline\n */\nexport function getOnlineStatusSync(): boolean {\n  // Browser environment\n  if (typeof window !== \"undefined\" && typeof navigator !== \"undefined\") {\n    return navigator.onLine;\n  }\n\n  // SSR, React Native, or unknown - assume online\n  // For RN, use getOnlineStatus() async version for accuracy\n  return true;\n}\n\n/**\n * Subscribe to network status changes\n *\n * @param callback - Function called when online status changes\n * @returns Unsubscribe function\n */\nexport function subscribeToNetworkChanges(\n  callback: (isOnline: boolean) => void\n): () => void {\n  // Try React Native NetInfo first\n  if (isReactNative()) {\n    let unsubscribe: NetInfoSubscription | null = null;\n\n    // Async setup for NetInfo\n    getNetInfo().then((netInfo) => {\n      if (netInfo) {\n        unsubscribe = netInfo.addEventListener((state) => {\n          callback(state.isConnected ?? true);\n        });\n      }\n    });\n\n    return () => {\n      if (unsubscribe) {\n        unsubscribe();\n      }\n    };\n  }\n\n  // Browser environment (not React Native or SSR)\n  const isBrowser = typeof window !== \"undefined\" && typeof window.addEventListener === \"function\";\n  if (isBrowser) {\n    const handleOnline = () => callback(true);\n    const handleOffline = () => callback(false);\n\n    window.addEventListener(\"online\", handleOnline);\n    window.addEventListener(\"offline\", handleOffline);\n\n    return () => {\n      window.removeEventListener(\"online\", handleOnline);\n      window.removeEventListener(\"offline\", handleOffline);\n    };\n  }\n\n  // SSR or unknown - no-op\n  return () => {};\n}\n\n/**\n * Initialize network monitoring (call early in app lifecycle)\n * This pre-loads NetInfo on React Native for faster subsequent calls\n */\nexport async function initializeNetworkMonitoring(): Promise<void> {\n  await getNetInfo();\n}\n"],"mappings":"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","names":["useState","useEffect","useState","useEffect"]}

package/dist/chunk-Y3INY2CS.js

@@ -0,0 +1,14 @@
+// src/config.ts
+var supabaseUrl = process.env.SUPABASE_URL;
+function setSupabaseUrl(url) {
+  supabaseUrl = url;
+}
+function getSupabaseUrl() {
+  return supabaseUrl;
+}
+
+export {
+  setSupabaseUrl,
+  getSupabaseUrl
+};
+//# sourceMappingURL=chunk-Y3INY2CS.js.map

package/dist/chunk-Y3INY2CS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/config.ts"],"sourcesContent":["let supabaseUrl = process.env.SUPABASE_URL;\n\nexport function setSupabaseUrl(url: string) {\n    supabaseUrl = url;\n}\n\nexport function getSupabaseUrl() {\n    return supabaseUrl;\n}\n"],"mappings":";AAAA,IAAI,cAAc,QAAQ,IAAI;AAEvB,SAAS,eAAe,KAAa;AACxC,gBAAc;AAClB;AAEO,SAAS,iBAAiB;AAC7B,SAAO;AACX;","names":[]}