@povio/ui 0.0.8 → 0.0.10

package/{src → dist}/types/react-query.d.ts

@@ -1,5 +1,5 @@
 import { InfiniteData, QueryKey, UseInfiniteQueryOptions, UseMutationOptions, UseQueryOptions } from '@tanstack/react-query';
-import { ApplicationException, GeneralErrorCodes } from '#ui/utils/vendor/error-handling';
+import { ApplicationException, GeneralErrorCodes } from '../utils/vendor/error-handling';
 import { Function, IsUnknown } from './common';
 export type AppQueryOptions<TFunction extends Function, TData = Awaited<ReturnType<TFunction>>, TErrorCodes = GeneralErrorCodes> = Omit<UseQueryOptions<Awaited<ReturnType<TFunction>>, ApplicationException<TErrorCodes>, IsUnknown<TData, Awaited<ReturnType<TFunction>>>>, "queryKey" | "queryFn">;
 export type AppMutationOptions<TFunction extends Function, TVariables = void, TData = Awaited<ReturnType<TFunction>>, TErrorCodes = GeneralErrorCodes> = Omit<UseMutationOptions<TData, ApplicationException<TErrorCodes>, TVariables>, "mutationKey" | "mutationFn">;

package/dist/utils/array.utils.js

@@ -0,0 +1,12 @@
+var ArrayUtils;
+((ArrayUtils2) => {
+  ArrayUtils2.fromCommaSeparatedStr = (str) => {
+    if (!str) {
+      return [];
+    }
+    return str.split(",").map((item) => item.trim());
+  };
+})(ArrayUtils || (ArrayUtils = {}));
+export {
+  ArrayUtils
+};

package/dist/utils/compoundMapper.js

@@ -0,0 +1,14 @@
+const compoundMapper = (config) => {
+  return (props) => {
+    const variant = config.compoundVariants?.find((v) => {
+      return Object.entries(v).filter(([key]) => key !== "value").every(([key, value]) => {
+        const prop = props[key] || config.defaultVariants?.[key];
+        return Array.isArray(value) ? value.includes(prop) : prop === value;
+      });
+    });
+    return variant?.value ?? config.default;
+  };
+};
+export {
+  compoundMapper
+};

package/dist/utils/date-time.utils.js

@@ -0,0 +1,77 @@
+import { parseAbsoluteToLocal, getLocalTimeZone, fromDate, CalendarDateTime, CalendarDate, parseAbsolute } from "@internationalized/date";
+var DateTimeUtils;
+((DateTimeUtils2) => {
+  function fromISOtoZonedDateTime(isoString) {
+    return parseAbsoluteToLocal(isoString);
+  }
+  DateTimeUtils2.fromISOtoZonedDateTime = fromISOtoZonedDateTime;
+  function fromDateValueToISO(dateValue) {
+    return dateValue.toDate(getLocalTimeZone()).toISOString();
+  }
+  DateTimeUtils2.fromDateValueToISO = fromDateValueToISO;
+  function fromLocalToZonedDateTime(date) {
+    return fromDate(date, getLocalTimeZone());
+  }
+  DateTimeUtils2.fromLocalToZonedDateTime = fromLocalToZonedDateTime;
+  function fromDateValueToLocal(dateValue) {
+    return dateValue.toDate(getLocalTimeZone());
+  }
+  DateTimeUtils2.fromDateValueToLocal = fromDateValueToLocal;
+  function fromCalendarDateToUTCISO(calendarDate, options = {}) {
+    if (options.endOfDay) {
+      const calendarDateTime = new CalendarDateTime(
+        calendarDate.year,
+        calendarDate.month,
+        calendarDate.day,
+        23,
+        59,
+        59,
+        999
+      );
+      return calendarDateTime.toDate("UTC").toISOString();
+    }
+    return calendarDate.toDate("UTC").toISOString();
+  }
+  DateTimeUtils2.fromCalendarDateToUTCISO = fromCalendarDateToUTCISO;
+  function fromUTCISOToCalendarDate(isoString) {
+    const date = new Date(isoString);
+    return new CalendarDate(date.getUTCFullYear(), date.getUTCMonth() + 1, date.getUTCDate());
+  }
+  DateTimeUtils2.fromUTCISOToCalendarDate = fromUTCISOToCalendarDate;
+  function fromCalendarDateTimeToUTCISO(calendarDateTime) {
+    return calendarDateTime.toDate("UTC").toISOString();
+  }
+  DateTimeUtils2.fromCalendarDateTimeToUTCISO = fromCalendarDateTimeToUTCISO;
+  function fromUTCISOToCalendarDateTime(isoString) {
+    const zonedDateTime = parseAbsolute(isoString, "UTC");
+    return new CalendarDateTime(
+      zonedDateTime.year,
+      zonedDateTime.month,
+      zonedDateTime.day,
+      zonedDateTime.hour,
+      zonedDateTime.minute,
+      zonedDateTime.second,
+      zonedDateTime.millisecond
+    );
+  }
+  DateTimeUtils2.fromUTCISOToCalendarDateTime = fromUTCISOToCalendarDateTime;
+  function formatTextDateToCalendarDateTime(textDate) {
+    if (!textDate?.includes("hh")) {
+      return null;
+    }
+    const datePart = textDate.split(",").at(0)?.trim();
+    if (!datePart) {
+      return null;
+    }
+    const date = new Date(datePart);
+    if (!date || date.toString() === "Invalid Date") {
+      return null;
+    }
+    const zonedDateTime = fromDate(date, getLocalTimeZone());
+    return new CalendarDateTime(zonedDateTime.year, zonedDateTime.month, zonedDateTime.day, 0, 0, 0, 0);
+  }
+  DateTimeUtils2.formatTextDateToCalendarDateTime = formatTextDateToCalendarDateTime;
+})(DateTimeUtils || (DateTimeUtils = {}));
+export {
+  DateTimeUtils
+};

package/dist/utils/date.utils.js

@@ -0,0 +1,12 @@
+import { DateTime } from "luxon";
+var DateUtils;
+((DateUtils2) => {
+  const DATE_FORMAT = "dd/MM/yyyy";
+  function formatDate(date, format = DATE_FORMAT) {
+    return DateTime.fromJSDate(date).toFormat(format);
+  }
+  DateUtils2.formatDate = formatDate;
+})(DateUtils || (DateUtils = {}));
+export {
+  DateUtils
+};

package/dist/utils/dom.utils.js

@@ -0,0 +1,13 @@
+var DomUtils;
+((DomUtils2) => {
+  const KEYBOARD_INPUTS = /* @__PURE__ */ new Set(["button", "submit", "checkbox", "file", "image"]);
+  DomUtils2.isKeyboardInput = (elem) => {
+    return elem.tagName === "INPUT" && !KEYBOARD_INPUTS.has(elem.type) || elem.hasAttribute("contenteditable");
+  };
+  DomUtils2.isKeyboardEvent = (event) => {
+    return event.nativeEvent instanceof KeyboardEvent;
+  };
+})(DomUtils || (DomUtils = {}));
+export {
+  DomUtils
+};

package/dist/utils/file.utils.js

@@ -0,0 +1,63 @@
+import { RestUtils } from "./rest.utils.js";
+var FileUtils;
+((FileUtils2) => {
+  FileUtils2.getObjectUrl = (data, revokeTimeoutMs = 4e4) => {
+    const url = URL.createObjectURL(data instanceof Blob ? data : data.data);
+    setTimeout(() => URL.revokeObjectURL(url), revokeTimeoutMs);
+    return url;
+  };
+  FileUtils2.openFile = (data, target = "_blank", revokeTimeoutMs) => {
+    const url = (0, FileUtils2.getObjectUrl)(data, revokeTimeoutMs);
+    window.open(url, target);
+  };
+  FileUtils2.downloadFile = (data, fileName, revokeTimeoutMs) => {
+    const url = (0, FileUtils2.getObjectUrl)(data, revokeTimeoutMs);
+    const contentDispositionFileName = data instanceof Blob ? void 0 : RestUtils.extractContentDispositionFilename(data.headers);
+    const a = document.createElement("a");
+    a.download = fileName ?? contentDispositionFileName ?? "download";
+    a.rel = "noopener";
+    a.href = url;
+    setTimeout(() => a.dispatchEvent(new MouseEvent("click")));
+  };
+  FileUtils2.isFileTypeAccepted = (file, fileTypes) => {
+    if (!fileTypes || fileTypes.length === 0) {
+      return true;
+    }
+    return fileTypes.some((type) => {
+      if (type.includes("/")) {
+        return file.type === type || type.endsWith("/*") && file.type.startsWith(type.slice(0, -1));
+      }
+      return file.name.toLowerCase().endsWith(type.toLowerCase());
+    });
+  };
+  FileUtils2.getCalculatedFileSize = (file) => {
+    if (!file) {
+      return "";
+    }
+    if (file.size < 1024) {
+      return `${file.size} B`;
+    }
+    if (file.size < 1024 * 1024) {
+      return `${(file.size / 1024).toFixed(2)} KB`;
+    }
+    if (file.size < 1024 * 1024 * 1024) {
+      return `${(file.size / 1024 / 1024).toFixed(2)} MB`;
+    }
+    return `${(file.size / 1024 / 1024 / 1024).toFixed(2)} GB`;
+  };
+  FileUtils2.formatBytes = (size, decimals = 2) => {
+    if (size < 1024) {
+      return `${size} B`;
+    }
+    if (size < 1024 * 1024) {
+      return `${(size / 1024).toFixed(decimals)} KB`;
+    }
+    if (size < 1024 * 1024 * 1024) {
+      return `${(size / 1024 / 1024).toFixed(decimals)} MB`;
+    }
+    return `${(size / 1024 / 1024 / 1024).toFixed(decimals)} GB`;
+  };
+})(FileUtils || (FileUtils = {}));
+export {
+  FileUtils
+};

package/dist/utils/isEqual.js

@@ -0,0 +1,95 @@
+import { ObjectUtils } from "./object.utils.js";
+const isEqual = (a, b) => {
+  return eq(a, b);
+};
+const eq = (a, b, aStack, bStack) => {
+  if (a === b) {
+    return a !== 0 || 1 / a === 1 / b;
+  }
+  if (a == null || b == null) {
+    return a === b;
+  }
+  if (a !== a) {
+    return b !== b;
+  }
+  const type = typeof a;
+  if (type !== "function" && type !== "object" && typeof b !== "object") {
+    return false;
+  }
+  return deepEq(a, b, aStack, bStack);
+};
+const deepEq = (a, b, aStack, bStack) => {
+  const className = toString.call(a);
+  if (className !== toString.call(b)) {
+    return false;
+  }
+  switch (className) {
+    // Strings, numbers, regular expressions, dates, and booleans are compared by value.
+    // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')
+    case "[object RegExp]":
+    case "[object String]":
+      return `${a}` === `${b}`;
+    case "[object Number]":
+      if (+a !== +a) {
+        return +b !== +b;
+      }
+      return +a === 0 ? 1 / +a === 1 / b : +a === +b;
+    case "[object Date]":
+    case "[object Boolean]":
+      return +a === +b;
+    case "[object Symbol]":
+      return Symbol.prototype.valueOf.call(a) === Symbol.prototype.valueOf.call(b);
+  }
+  const areArrays = className === "[object Array]";
+  if (!areArrays) {
+    if (typeof a !== "object" || typeof b !== "object") {
+      return false;
+    }
+    const aCtor = a.constructor;
+    const bCtor = b.constructor;
+    if (aCtor !== bCtor && !(ObjectUtils.isFunction(aCtor) && aCtor instanceof aCtor && ObjectUtils.isFunction(bCtor) && bCtor instanceof bCtor) && "constructor" in a && "constructor" in b) {
+      return false;
+    }
+  }
+  aStack = aStack || [];
+  bStack = bStack || [];
+  let { length } = aStack;
+  while (length--) {
+    if (aStack[length] === a) {
+      return bStack[length] === b;
+    }
+  }
+  aStack.push(a);
+  bStack.push(b);
+  if (areArrays) {
+    length = a.length;
+    if (length !== b.length) {
+      return false;
+    }
+    while (length--) {
+      if (!eq(a[length], b[length], aStack, bStack)) {
+        return false;
+      }
+    }
+  } else {
+    const keys = Object.keys(a);
+    let key;
+    length = keys.length;
+    if (Object.keys(b).length !== length) {
+      return false;
+    }
+    while (length--) {
+      key = keys[length];
+      if (!(Object.prototype.hasOwnProperty.call(b, key) && // oxlint-disable-next-line no-explicit-any
+      eq(a[key], b[key], aStack, bStack))) {
+        return false;
+      }
+    }
+  }
+  aStack.pop();
+  bStack.pop();
+  return true;
+};
+export {
+  isEqual
+};

package/dist/utils/logger.js

@@ -0,0 +1,19 @@
+import log from "loglevel";
+import prefix from "loglevel-plugin-prefix";
+prefix.reg(log);
+prefix.apply(log, {
+  template: "[%t] %l:",
+  timestampFormatter: (date) => {
+    return date.toISOString();
+  }
+});
+const logger = {
+  info: (...args) => log.info(...args),
+  debug: (...args) => log.debug(...args),
+  warn: (...args) => log.warn(...args),
+  error: (...args) => log.error(...args),
+  trace: (...args) => log.trace(...args)
+};
+export {
+  logger
+};

package/dist/utils/object.utils.js

@@ -0,0 +1,53 @@
+var ObjectUtils;
+((ObjectUtils2) => {
+  ObjectUtils2.isNil = (obj) => {
+    return obj === null || obj === void 0;
+  };
+  ObjectUtils2.isFunction = (obj) => {
+    return typeof obj === "function";
+  };
+  ObjectUtils2.isObject = (obj) => {
+    return typeof obj === "object" && !!obj;
+  };
+  ObjectUtils2.isString = (obj) => {
+    return Object.prototype.toString.call(obj) === "[object String]";
+  };
+  ObjectUtils2.isDate = (obj) => {
+    return Object.prototype.toString.call(obj) === "[object Date]";
+  };
+  ObjectUtils2.isRegExp = (obj) => {
+    return Object.prototype.toString.call(obj) === "[object RegExp]";
+  };
+  ObjectUtils2.isEmpty = (obj) => {
+    if (obj === null || obj === void 0) {
+      return true;
+    }
+    if (Array.isArray(obj) || (0, ObjectUtils2.isString)(obj)) {
+      return obj.length === 0;
+    }
+    return Object.keys(obj).length === 0;
+  };
+  ObjectUtils2.deepConditionalMerge = (target, source, condition) => {
+    const output = { ...target };
+    for (const key in source) {
+      if (Object.prototype.hasOwnProperty.call(source, key)) {
+        const value = source[key];
+        if (condition(value, key)) {
+          if (typeof value === "object" && !Array.isArray(value)) {
+            output[key] = (0, ObjectUtils2.deepConditionalMerge)(
+              output[key],
+              value,
+              condition
+            );
+          } else {
+            output[key] = value;
+          }
+        }
+      }
+    }
+    return output;
+  };
+})(ObjectUtils || (ObjectUtils = {}));
+export {
+  ObjectUtils
+};

package/dist/utils/queries.utils.js

@@ -0,0 +1,9 @@
+var QueriesUtils;
+((QueriesUtils2) => {
+  QueriesUtils2.prefetchMultipleQueries = (queryClient, queries) => {
+    return Promise.all(queries.map((query) => query(queryClient)));
+  };
+})(QueriesUtils || (QueriesUtils = {}));
+export {
+  QueriesUtils
+};

package/dist/utils/rest.utils.js

@@ -0,0 +1,51 @@
+import axios from "axios";
+import { z } from "zod";
+var RestUtils;
+((RestUtils2) => {
+  RestUtils2.extractServerResponseCode = (e) => {
+    if (e instanceof z.ZodError) {
+      return "validation-exception";
+    }
+    if (!axios.isAxiosError(e)) {
+      return null;
+    }
+    if (!e.response) {
+      return null;
+    }
+    const data = e.response.data;
+    if (typeof data?.code === "string") {
+      return data.code;
+    }
+    return null;
+  };
+  RestUtils2.doesServerErrorMessageContain = (e, text) => {
+    const message = (0, RestUtils2.extractServerErrorMessage)(e);
+    if (message === null || message === void 0) {
+      return false;
+    }
+    return message.toLowerCase().includes(text.toLowerCase());
+  };
+  RestUtils2.extractServerErrorMessage = (e) => {
+    if (e instanceof z.ZodError) {
+      return e.message;
+    }
+    if (!axios.isAxiosError(e)) {
+      return null;
+    }
+    if (!e.response) {
+      return null;
+    }
+    const data = e.response.data;
+    if (typeof data?.message === "string") {
+      return data.message;
+    }
+    return null;
+  };
+  RestUtils2.extractContentDispositionFilename = (headers) => {
+    const contentDisposition = headers["content-disposition"];
+    return contentDisposition ? /filename=["']?([^"';]+)/i.exec(contentDisposition)?.[1] : void 0;
+  };
+})(RestUtils || (RestUtils = {}));
+export {
+  RestUtils
+};

package/dist/utils/routing.utils.js

@@ -0,0 +1,15 @@
+var RoutingUtils;
+((RoutingUtils2) => {
+  RoutingUtils2.addQueryParams = (path, params) => {
+    const sParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value) {
+        sParams.append(key, value.toString());
+      }
+    }
+    return `${path}?${sParams.toString()}`;
+  };
+})(RoutingUtils || (RoutingUtils = {}));
+export {
+  RoutingUtils
+};

package/dist/utils/string.utils.js

@@ -0,0 +1,12 @@
+var StringUtils;
+((StringUtils2) => {
+  StringUtils2.containsCaseInsensitive = (str, substr) => {
+    return str.toLowerCase().includes(substr.toLowerCase());
+  };
+  StringUtils2.capitalize = (str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  };
+})(StringUtils || (StringUtils = {}));
+export {
+  StringUtils
+};

package/{src → dist}/utils/vendor/acl/AclGuard.d.ts

@@ -1,4 +1,4 @@
-import { WithPrivateAuthGuardProps } from '#ui/utils/vendor/auth/withPrivateAuthGuard';
+import { WithPrivateAuthGuardProps } from '../auth/withPrivateAuthGuard';
 import { AppAbilities } from './appAbility.types';
 export declare const createAclGuard: <TAppAbilities extends AppAbilities = AppAbilities>() => ({ privateAuthGuardProps, ...props }: {
     canUse: TAppAbilities;

package/dist/utils/vendor/acl/AclGuard.js

@@ -0,0 +1,15 @@
+import { UIRouter } from "../../../config/router.context.js";
+import { AbilityContext } from "./ability.context.js";
+import { withPrivateAuthGuard } from "../auth/withPrivateAuthGuard.js";
+const createAclGuard = () => withPrivateAuthGuard(({ canUse, redirectTo = "/", children }) => {
+  const ability = AbilityContext.useAbility();
+  const { replace } = UIRouter.useUIRouter();
+  if (!ability.can(canUse[0], canUse[1])) {
+    replace(redirectTo);
+    return null;
+  }
+  return children;
+});
+export {
+  createAclGuard
+};

package/dist/utils/vendor/acl/Can.js

@@ -0,0 +1,18 @@
+import { jsx } from "react/jsx-runtime";
+import { createContextualCan } from "@casl/react";
+import { AbilityContext } from "./ability.context.js";
+const ContextualCan = createContextualCan(AbilityContext.Consumer);
+const Can = ({ use, ...props }) => {
+  const [action, subject] = use;
+  return /* @__PURE__ */ jsx(
+    ContextualCan,
+    {
+      ...props,
+      do: action,
+      on: subject
+    }
+  );
+};
+export {
+  Can
+};

package/dist/utils/vendor/acl/ability.context.js

@@ -0,0 +1,37 @@
+import { jsx } from "react/jsx-runtime";
+import { AbilityBuilder, createMongoAbility } from "@casl/ability";
+import { unpackRules } from "@casl/ability/extra";
+import { useAbility } from "@casl/react";
+import { createContext, useState, useEffect } from "react";
+import { AuthContext } from "../auth/auth.context.js";
+var AbilityContext;
+((AbilityContext2) => {
+  const createAppAbilityBuilder = () => new AbilityBuilder(createMongoAbility);
+  const initialAppAbility = createAppAbilityBuilder().build();
+  const Context = createContext({});
+  ({ Consumer: AbilityContext2.Consumer } = Context);
+  AbilityContext2.Provider = ({ children }) => {
+    const [ability, setAbility] = useState(initialAppAbility);
+    const { user } = AuthContext.useAuth();
+    useEffect(() => {
+      if (!user || !("aclRules" in user)) {
+        return;
+      }
+      const { can, build } = createAppAbilityBuilder();
+      const packedRules = user.aclRules;
+      const rules = unpackRules(packedRules);
+      rules.forEach(({ action, subject, conditions }) => {
+        can(action, subject, conditions);
+      });
+      setAbility(build());
+    }, [user]);
+    return /* @__PURE__ */ jsx(Context.Provider, { value: ability, children });
+  };
+  AbilityContext2.useAbility = () => {
+    const ability = useAbility(Context);
+    return ability;
+  };
+})(AbilityContext || (AbilityContext = {}));
+export {
+  AbilityContext
+};

package/dist/utils/vendor/auth/AuthGuard.js

@@ -0,0 +1,26 @@
+import { useState, useEffect } from "react";
+import { UIRouter } from "../../../config/router.context.js";
+import { AuthContext } from "./auth.context.js";
+const AuthGuard = ({ type, redirectTo, children }) => {
+  const { isAuthenticated, routes, loadingState } = AuthContext.useAuth();
+  const { replace } = UIRouter.useUIRouter();
+  const [hasMounted, setHasMounted] = useState(false);
+  useEffect(() => {
+    setHasMounted(true);
+  }, []);
+  if (!hasMounted) {
+    return loadingState;
+  }
+  if (type === "private" && !isAuthenticated) {
+    replace(redirectTo || routes?.unauthenticated || "/");
+    return null;
+  }
+  if (type === "public-only" && isAuthenticated) {
+    replace(redirectTo || routes?.authenticated || "/");
+    return null;
+  }
+  return children;
+};
+export {
+  AuthGuard
+};

package/dist/utils/vendor/auth/auth.context.js

@@ -0,0 +1,36 @@
+import { jsx } from "react/jsx-runtime";
+import { createContext, use } from "react";
+var AuthContext;
+((AuthContext2) => {
+  const Context = createContext({});
+  AuthContext2.Provider = ({
+    isAuthenticated,
+    isInitializing,
+    logout,
+    updateTokens,
+    accessToken,
+    user,
+    routes,
+    loadingState,
+    children
+  }) => {
+    const value = {
+      isAuthenticated,
+      isInitializing,
+      logout,
+      updateTokens,
+      accessToken,
+      user,
+      routes,
+      loadingState
+    };
+    return /* @__PURE__ */ jsx(Context.Provider, { value, children });
+  };
+  AuthContext2.useAuth = () => {
+    const auth = use(Context);
+    return auth;
+  };
+})(AuthContext || (AuthContext = {}));
+export {
+  AuthContext
+};

package/{src → dist}/utils/vendor/auth/withPrivateAuthGuard.d.ts

@@ -1,5 +1,5 @@
 import { ComponentType, PropsWithChildren } from 'react';
-import { AuthGuardProps } from '#ui/utils/vendor/auth/AuthGuard';
+import { AuthGuardProps } from './AuthGuard';
 export interface WithPrivateAuthGuardProps {
     privateAuthGuardProps?: Omit<AuthGuardProps, "type">;
 }

package/dist/utils/vendor/auth/withPrivateAuthGuard.js

@@ -0,0 +1,17 @@
+import { jsx } from "react/jsx-runtime";
+import { AuthGuard } from "./AuthGuard.js";
+const withPrivateAuthGuard = (WrappedComponent) => {
+  return ({ privateAuthGuardProps, ...props }) => {
+    return /* @__PURE__ */ jsx(
+      AuthGuard,
+      {
+        type: "private",
+        ...privateAuthGuardProps,
+        children: /* @__PURE__ */ jsx(WrappedComponent, { ...props })
+      }
+    );
+  };
+};
+export {
+  withPrivateAuthGuard
+};