@povio/ui 0.0.8 → 0.0.9

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
+};

package/dist/utils/vendor/error-handling.js

@@ -0,0 +1,119 @@
+import axios from "axios";
+import i18next from "i18next";
+import { z } from "zod";
+import { ns } from "../../config/i18n.js";
+import { logger } from "../logger.js";
+import { RestUtils } from "../rest.utils.js";
+class ApplicationException extends Error {
+  constructor(message, code, serverMessage) {
+    super(message);
+    this.serverMessage = null;
+    this.code = code;
+    this.serverMessage = serverMessage;
+  }
+}
+class ErrorHandler {
+  constructor(entries) {
+    this.entries = [];
+    const dataValidationError = {
+      code: "DATA_VALIDATION_ERROR",
+      condition: (e) => {
+        return e instanceof z.ZodError;
+      },
+      getMessage: () => i18next.t(($) => $.sharedErrors.dataValidation, {
+        ns
+      })
+    };
+    const internalError = {
+      code: "INTERNAL_ERROR",
+      condition: (e) => {
+        if (axios.isAxiosError(e)) {
+          return e.response?.status != null && e.response.status >= 500 && e.response.status < 600;
+        }
+        return false;
+      },
+      getMessage: () => i18next.t(($) => $.sharedErrors.internalError, {
+        ns
+      })
+    };
+    const networkError = {
+      code: "NETWORK_ERROR",
+      condition: (e) => {
+        if (axios.isAxiosError(e)) {
+          return e.code === "ERR_NETWORK";
+        }
+        return false;
+      },
+      getMessage: () => i18next.t(($) => $.sharedErrors.networkError, {
+        ns
+      })
+    };
+    const canceledError = {
+      code: "CANCELED_ERROR",
+      condition: (e) => {
+        if (axios.isCancel(e)) {
+          return true;
+        }
+        if (axios.isAxiosError(e) && e.code === "ECONNABORTED") {
+          return true;
+        }
+        return false;
+      },
+      getMessage: () => i18next.t(($) => $.sharedErrors.canceledError, {
+        ns
+      })
+    };
+    const unknownError = {
+      code: "UNKNOWN_ERROR",
+      condition: () => true,
+      getMessage: () => i18next.t(($) => $.sharedErrors.unknownError, {
+        ns
+      })
+    };
+    this.entries = [...entries, dataValidationError, internalError, networkError, canceledError, unknownError];
+  }
+  // convert the error into an application exception
+  rethrowError(error) {
+    logger.error(error);
+    const errorEntry = this.entries.find((entry) => entry.condition(error ?? {}));
+    const serverMessage = RestUtils.extractServerErrorMessage(error);
+    throw new ApplicationException(errorEntry.getMessage(error), errorEntry.code, serverMessage);
+  }
+  // oxlint-disable-next-line class-methods-use-this
+  getError(error) {
+    if (error instanceof ApplicationException) {
+      return error;
+    }
+    return null;
+  }
+  // oxlint-disable-next-line class-methods-use-this
+  getErrorCode(error) {
+    if (error instanceof ApplicationException) {
+      return error.code;
+    }
+    return null;
+  }
+  static getErrorMessage(error, fallbackToUnknown = true) {
+    if (typeof error === "string") {
+      return error;
+    }
+    if (error instanceof Error) {
+      return error.message;
+    }
+    if (error instanceof ApplicationException) {
+      return error.message;
+    }
+    if (fallbackToUnknown) {
+      return i18next.t(($) => $.sharedErrors.unknownError, {
+        ns
+      });
+    }
+    return null;
+  }
+}
+const SharedErrorHandler = new ErrorHandler([]);
+export {
+  ApplicationException,
+  ErrorHandler,
+  SharedErrorHandler
+};

package/dist/utils/vendor/rest-interceptor.js

@@ -0,0 +1,21 @@
+class RestInterceptor {
+  constructor(applyInterceptor) {
+    this.applyInterceptor = applyInterceptor;
+    this.interceptorIdMap = [];
+  }
+  addInterceptor(client, ...args) {
+    this.removeInterceptor(client);
+    const interceptorId = this.applyInterceptor(client, ...args);
+    this.interceptorIdMap.push({ client, interceptorId });
+  }
+  removeInterceptor(client) {
+    const interceptorId = this.interceptorIdMap.find((i) => i.client === client)?.interceptorId;
+    if (interceptorId != null) {
+      client.interceptors.request.eject(interceptorId);
+      this.interceptorIdMap = this.interceptorIdMap.filter((i) => i.client !== client);
+    }
+  }
+}
+export {
+  RestInterceptor
+};

package/dist/utils/zod.utils.js

@@ -0,0 +1,25 @@
+import { z } from "zod";
+var ZodUtils;
+((ZodUtils2) => {
+  ZodUtils2.unwrapZodType = (schemaType) => {
+    let unwrappedType = schemaType;
+    while (unwrappedType instanceof z.ZodNullable || unwrappedType instanceof z.ZodOptional) {
+      unwrappedType = unwrappedType.unwrap();
+    }
+    return unwrappedType;
+  };
+  const hasZodObjectProperty = (schemaType, property, type) => {
+    return property in schemaType.shape && schemaType.shape[property] instanceof z.core.$ZodType && (0, ZodUtils2.unwrapZodType)(schemaType.shape[property]) instanceof type;
+  };
+  ZodUtils2.isDateRange = (schemaType) => {
+    const unwrappedType = (0, ZodUtils2.unwrapZodType)(schemaType);
+    return unwrappedType instanceof z.ZodObject && hasZodObjectProperty(unwrappedType, "start", z.ZodISODateTime) && hasZodObjectProperty(unwrappedType, "end", z.ZodISODateTime);
+  };
+  ZodUtils2.isTextEditor = (schemaType) => {
+    const unwrappedType = (0, ZodUtils2.unwrapZodType)(schemaType);
+    return unwrappedType instanceof z.ZodObject && hasZodObjectProperty(unwrappedType, "html", z.ZodString) && hasZodObjectProperty(unwrappedType, "json", z.ZodObject);
+  };
+})(ZodUtils || (ZodUtils = {}));
+export {
+  ZodUtils
+};

package/package.json

@@ -1,17 +1,69 @@
 {
   "name": "@povio/ui",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "type": "module",
-  "main": "index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
   "exports": {
-    ".": "./index.ts",
-    "./styles": "./index.css"
+    ".": "./dist/index.js",
+    "./styles": "./dist/styles/index.css"
   },
-  "types": "./index.d.ts",
+  "files": [
+    "dist"
+  ],
   "homepage": "https://povio.com",
   "license": "UNLICENSED",
   "peerDependencies": {
     "react": "^19.1.0",
     "react-dom": "^19.1.0"
+  },
+  "dependencies": {
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/modifiers": "^9.0.0",
+    "@dnd-kit/sortable": "^10.0.0",
+    "@dnd-kit/utilities": "^3.2.2",
+    "@hookform/resolvers": "^5.2.2",
+    "@internationalized/date": "^3.10.0",
+    "@react-aria/button": "^3.14.2",
+    "@react-aria/calendar": "^3.9.2",
+    "@react-aria/focus": "^3.21.2",
+    "@react-aria/i18n": "^3.12.13",
+    "@react-aria/utils": "^3.31.0",
+    "@react-stately/calendar": "^3.9.0",
+    "@react-stately/datepicker": "^3.15.2",
+    "@react-types/shared": "^3.32.1",
+    "@tanstack/react-query": "~5.85.9",
+    "@tanstack/react-table": "^8.21.3",
+    "@tiptap/core": "^2.26.3",
+    "@tiptap/extension-color": "^2.26.3",
+    "@tiptap/extension-heading": "^2.26.3",
+    "@tiptap/extension-highlight": "^2.26.3",
+    "@tiptap/extension-link": "^2.26.3",
+    "@tiptap/extension-placeholder": "^2.26.3",
+    "@tiptap/extension-text-align": "^2.26.3",
+    "@tiptap/extension-text-style": "^2.26.3",
+    "@tiptap/extension-underline": "^2.26.3",
+    "@tiptap/pm": "^2.26.3",
+    "@tiptap/react": "^2.26.3",
+    "@tiptap/starter-kit": "^2.26.3",
+    "axios": "^1.13.1",
+    "class-variance-authority": "^0.7.1",
+    "clsx": "^2.1.1",
+    "i18next": "^25.6.0",
+    "loglevel": "^1.9.2",
+    "loglevel-plugin-prefix": "^0.8.4",
+    "luxon": "^3.7.2",
+    "motion": "~12.23.24",
+    "react-aria": "^3.44.0",
+    "react-aria-components": "^1.13.0",
+    "react-hook-form": "^7.65.0",
+    "react-i18next": "^16.2.3",
+    "react-responsive": "^10.0.1",
+    "react-stately": "^3.42.0",
+    "react-toastify": "^11.0.5",
+    "react-use-measure": "^2.1.7",
+    "tailwindcss": "^4.1.15",
+    "tailwindcss-react-aria-components": "^2.0.1",
+    "zod": "^4.1.12"
   }
 }