@povio/ui 0.0.6 → 0.0.8

package/dist/config/confirmation.context.js

@@ -1,107 +0,0 @@
-import { jsxs, jsx } from "react/jsx-runtime";
-import { createContext, useState, useCallback, useMemo, use } from "react";
-import { useTranslation } from "react-i18next";
-import { ActionModal } from "../components/overlays/ActionModal/ActionModal.js";
-import { ns } from "./i18n.js";
-var Confirmation;
-((Confirmation2) => {
-  const DEFAULT_STATE = {
-    heading: "",
-    description: "",
-    isOpen: false,
-    primaryAction: {
-      label: "",
-      onPress: () => {
-      }
-    },
-    secondaryAction: {
-      label: "",
-      onPress: () => {
-      }
-    }
-  };
-  const Context = createContext(null);
-  Confirmation2.Provider = ({ children }) => {
-    const [state, setState] = useState(DEFAULT_STATE);
-    const { t } = useTranslation(ns);
-    const onCancel = () => setState(DEFAULT_STATE);
-    const confirm = useCallback(
-      async ({
-        heading,
-        description,
-        buttonSize,
-        textAlign,
-        modalClassName,
-        cancelLabel = t(($) => $.ui.confirmation.cancel),
-        confirmLabel = t(($) => $.ui.confirmation.confirm),
-        confirmVariant,
-        confirmColor,
-        cancelVariant,
-        cancelColor
-      }) => {
-        return new Promise((resolve) => {
-          setState({
-            heading,
-            description,
-            buttonSize,
-            textAlign,
-            modalClassName,
-            primaryAction: {
-              label: confirmLabel,
-              onPress() {
-                setState({
-                  ...state,
-                  isOpen: false,
-                  heading: "",
-                  description: ""
-                });
-                resolve(true);
-              },
-              variant: confirmVariant,
-              color: confirmColor
-            },
-            secondaryAction: {
-              label: cancelLabel,
-              onPress() {
-                onCancel();
-                resolve(false);
-              },
-              variant: cancelVariant,
-              color: cancelColor
-            },
-            isOpen: !state.isOpen
-          });
-        });
-      },
-      [state, t]
-    );
-    const value = useMemo(
-      () => ({
-        confirm
-      }),
-      [confirm]
-    );
-    return /* @__PURE__ */ jsxs(Context.Provider, { value, children: [
-      /* @__PURE__ */ jsx(
-        ActionModal,
-        {
-          ...state,
-          onClose: state.secondaryAction?.onPress ?? onCancel,
-          primaryAction: state.primaryAction,
-          secondaryAction: state.secondaryAction
-        }
-      ),
-      children
-    ] });
-  };
-  Confirmation2.useConfirmation = () => {
-    const context = use(Context);
-    if (!context) {
-      throw new Error("Confirmation.useConfirmation must be used within a Confirmation.Provider");
-    }
-    return context;
-  };
-})(Confirmation || (Confirmation = {}));
-export {
-  Confirmation
-};

package/dist/config/i18n.js

@@ -1,15 +0,0 @@
-import translationEN from "../assets/locales/en/translation.json.js";
-import translationSL from "../assets/locales/sl/translation.json.js";
-const ns = "ui";
-const resources = {
-  en: {
-    [ns]: translationEN
-  },
-  sl: {
-    [ns]: translationSL
-  }
-};
-export {
-  ns,
-  resources
-};

package/dist/config/router.context.js

@@ -1,43 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { createContext, use } from "react";
-import { RouterProvider } from "react-aria";
-var UIRouter;
-((UIRouter2) => {
-  const UIRouterContext = createContext(null);
-  UIRouter2.UIRouterProvider = ({
-    children,
-    pathname,
-    push,
-    query,
-    replace
-  }) => {
-    const searchParams = new URLSearchParams();
-    for (const [k, v] of Object.entries(query)) {
-      if (Array.isArray(v)) {
-        for (const item of v) {
-          searchParams.append(k, item);
-        }
-      } else {
-        searchParams.set(k, v);
-      }
-    }
-    const value = {
-      searchParams,
-      pathname,
-      push,
-      query,
-      replace
-    };
-    return /* @__PURE__ */ jsx(UIRouterContext, { value, children: /* @__PURE__ */ jsx(RouterProvider, { navigate: (href) => push(href), children }) });
-  };
-  UIRouter2.useUIRouter = () => {
-    const context = use(UIRouterContext);
-    if (!context) {
-      throw new Error("useUIRouter must be used within a UIRouterContext");
-    }
-    return context;
-  };
-})(UIRouter || (UIRouter = {}));
-export {
-  UIRouter
-};

package/dist/config/uiConfig.context.js

@@ -1,62 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { createContext, use } from "react";
-import { useDeepCompareMemo } from "../hooks/useDeepCompare.js";
-import { ObjectUtils } from "../utils/object.utils.js";
-var UIConfig;
-((UIConfig2) => {
-  const DEFAULT_CONFIG = {
-    input: {
-      variant: "outlined",
-      as: "default",
-      size: "default",
-      isClearable: false,
-      hideLabel: false
-    },
-    numberInput: {
-      formatOptions: {
-        minimumFractionDigits: 0,
-        maximumFractionDigits: 3
-      }
-    },
-    radioGroup: {
-      variant: "default",
-      hideLabel: false
-    },
-    checkbox: {
-      variant: "default"
-    },
-    select: {
-      selectionMode: "single",
-      isSearchable: false
-    },
-    toggle: {
-      variant: "default"
-    },
-    slider: {
-      minValue: 0,
-      maxValue: 100
-    }
-  };
-  const Context = createContext(DEFAULT_CONFIG);
-  UIConfig2.Provider = ({ config = {}, children }) => {
-    const parentConfig = use(Context) || DEFAULT_CONFIG;
-    const value = useDeepCompareMemo(() => {
-      return ObjectUtils.deepConditionalMerge(
-        parentConfig,
-        config,
-        (val) => val !== null && val !== void 0
-      );
-    }, [config, parentConfig]);
-    return /* @__PURE__ */ jsx(Context.Provider, { value, children });
-  };
-  UIConfig2.useConfig = () => {
-    const context = use(Context);
-    if (!context) {
-      throw new Error("UIConfig.useConfig must be used within a UIConfig.Provider");
-    }
-    return context;
-  };
-})(UIConfig || (UIConfig = {}));
-export {
-  UIConfig
-};

package/dist/config/uiStyle.context.js

@@ -1,16 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import { createContext, use } from "react";
-var UIStyle;
-((UIStyle2) => {
-  const Context = createContext(null);
-  UIStyle2.Provider = ({ children, config }) => {
-    return /* @__PURE__ */ jsx(Context.Provider, { value: config, children });
-  };
-  UIStyle2.useConfig = () => {
-    const context = use(Context);
-    return context;
-  };
-})(UIStyle || (UIStyle = {}));
-export {
-  UIStyle
-};

package/dist/helpers/dynamicColumns.js

@@ -1,359 +0,0 @@
-import i18next from "i18next";
-import { z } from "zod";
-import { DateUtils } from "../utils/date.utils.js";
-import { StringUtils } from "../utils/string.utils.js";
-import { ZodUtils } from "../utils/zod.utils.js";
-const DEFAULT_NAMESPACE = "dynamicColumns";
-const FORMAT_MAP = {
-  datetime: (value) => DateUtils.formatDate(new Date(value)),
-  dateRange: (value) => {
-    const startDate = DateUtils.formatDate(new Date(value.start));
-    const endDate = DateUtils.formatDate(new Date(value.end));
-    return `${startDate} - ${endDate}`;
-  },
-  enum: (value) => StringUtils.capitalize(value),
-  number: (value) => value.toLocaleString(i18next.language),
-  string: (value) => String(value),
-  boolean: (value) => {
-    const key = `${DEFAULT_NAMESPACE}.${value ? "yes" : "no"}`;
-    if (i18next.exists(key)) {
-      return String(i18next.t(key));
-    }
-    return value ? "Yes" : "No";
-  }
-};
-const ZOD_TYPE_FORMAT_MAP = [
-  [z.ZodEnum, FORMAT_MAP.enum],
-  [z.ZodNumber, FORMAT_MAP.number],
-  [z.ZodString, FORMAT_MAP.string],
-  [z.ZodBoolean, FORMAT_MAP.boolean],
-  [z.ZodISODateTime, FORMAT_MAP.datetime]
-];
-const configValueToColumnDef = (value) => {
-  if (typeof value === "function" || typeof value === "string") {
-    return {
-      cell: value
-    };
-  }
-  if (typeof value === "boolean" || value === void 0) {
-    return {};
-  }
-  return value;
-};
-const convertEntriesToColumnDefs = (entries) => {
-  return entries.map(([key, value]) => [key, configValueToColumnDef(value)]);
-};
-const customConfigValueToColumnDef = (value) => {
-  if (typeof value === "string") {
-    return {
-      accessorKey: value,
-      cell: value
-    };
-  }
-  if (typeof value === "function") {
-    return {
-      cell: value
-    };
-  }
-  return value;
-};
-const convertCustomEntriesToColumnDefs = (entries) => {
-  return entries.map(([key, value]) => [key, customConfigValueToColumnDef(value)]);
-};
-const excludeEntries = (entries) => {
-  return entries.filter(([, value]) => value !== false && value !== void 0);
-};
-const sortColumns = (columns, orderKeys) => {
-  if (!orderKeys) {
-    return columns;
-  }
-  const wildcardIndex = orderKeys.indexOf("*");
-  if (wildcardIndex === -1) {
-    return columns.sort((columnA, columnB) => {
-      const idA = columnA.id;
-      const idB = columnB.id;
-      const orderMap = new Map(orderKeys.map((key, index) => [String(key), index]));
-      const orderA = orderMap.get(String(idA));
-      const orderB = orderMap.get(String(idB));
-      if (orderA !== void 0 && orderB !== void 0) {
-        return orderA - orderB;
-      }
-      if (orderA !== void 0 && orderB === void 0) {
-        return -1;
-      }
-      if (orderA === void 0 && orderB !== void 0) {
-        return 1;
-      }
-      return 0;
-    });
-  }
-  const beforeWildcard = orderKeys.slice(0, wildcardIndex);
-  const afterWildcard = orderKeys.slice(wildcardIndex + 1);
-  const beforeMap = new Map(beforeWildcard.map((key, index) => [String(key), index]));
-  const afterMap = new Map(afterWildcard.map((key, index) => [String(key), index]));
-  const before = [];
-  const middle = [];
-  const after = [];
-  columns.forEach((column) => {
-    const id = String(column.id);
-    if (beforeMap.has(id)) {
-      before.push(column);
-    } else if (afterMap.has(id)) {
-      after.push(column);
-    } else {
-      middle.push(column);
-    }
-  });
-  before.sort((a, b) => beforeMap.get(String(a.id)) - beforeMap.get(String(b.id)));
-  after.sort((a, b) => afterMap.get(String(a.id)) - afterMap.get(String(b.id)));
-  return [...before, ...middle, ...after];
-};
-const formatValueByType = (value, schemaType) => {
-  if (value === null || value === void 0) {
-    return null;
-  }
-  if (ZodUtils.isDateRange(schemaType)) {
-    return FORMAT_MAP.dateRange(value);
-  }
-  const unwrappedType = ZodUtils.unwrapZodType(schemaType);
-  if (unwrappedType instanceof z.ZodArray) {
-    if (!Array.isArray(value)) {
-      return null;
-    }
-    const elementType = unwrappedType.element;
-    const formattedElements = value.map((element) => formatValueByType(element, elementType));
-    return formattedElements.join(", ");
-  }
-  const formatFunction = ZOD_TYPE_FORMAT_MAP.find(([zodType]) => unwrappedType instanceof zodType)?.[1];
-  if (formatFunction) {
-    return formatFunction(value);
-  }
-  return String(value);
-};
-const getNestedValue = (obj, path) => {
-  return path.split(".").reduce((current, key) => {
-    return current && typeof current === "object" ? current[key] : void 0;
-  }, obj);
-};
-const getKeyType = (schema, key) => {
-  const pathParts = key.split(".");
-  let currentType = schema.shape[pathParts[0]];
-  for (let i = 1; i < pathParts.length; i++) {
-    if (currentType instanceof z.ZodObject) {
-      currentType = currentType.shape[pathParts[i]];
-    } else {
-      currentType = schema.shape[key];
-      break;
-    }
-  }
-  return currentType;
-};
-const getCellFunction = (schema, schemaKey, columnDef, options) => {
-  const { cell } = columnDef;
-  if (typeof cell === "function") {
-    return cell;
-  }
-  return ({ data }) => {
-    const isCellKeyString = typeof cell === "string";
-    const key = isCellKeyString ? cell : schemaKey;
-    const value = getNestedValue(data, key);
-    const keyType = getKeyType(schema, key);
-    const shouldFormat = !options.disableFormatting?.includes(key);
-    const formattedValue = shouldFormat ? formatValueByType(value, keyType) : value;
-    let finalValue = formattedValue;
-    if (options.emptyValue && !finalValue) {
-      finalValue = options.emptyValue;
-    }
-    if (options.globalWrapper) {
-      return options.globalWrapper(finalValue);
-    }
-    return finalValue;
-  };
-};
-const normalizeSortable = (sortable) => {
-  if (!sortable) {
-    return void 0;
-  }
-  if (Array.isArray(sortable)) {
-    return sortable;
-  }
-  if (sortable instanceof z.ZodEnum) {
-    return Object.values(sortable.enum);
-  }
-  return void 0;
-};
-const getDefaultColumnHeader = (key, options) => {
-  const namespace = options.namespace ?? DEFAULT_NAMESPACE;
-  const localeKey = `${namespace}.${key}`;
-  if (i18next.exists(localeKey)) {
-    return String(i18next.t(localeKey));
-  }
-  return StringUtils.capitalize(key);
-};
-const overridePresetColumnsHeaders = (presetColumns, options) => {
-  const namespace = options.namespace ?? DEFAULT_NAMESPACE;
-  return presetColumns.map((columnDef) => {
-    const localeKey = `${namespace}.${columnDef.id}`;
-    const header = i18next.exists(localeKey) ? i18next.t(localeKey) : columnDef.header;
-    return {
-      ...columnDef,
-      header: typeof header === "string" ? header : columnDef.header
-    };
-  });
-};
-const populateColumnDef = (schema, key, columnDef, options, sortableKeys) => {
-  const id = columnDef.id ?? key;
-  const enableSorting = columnDef.enableSorting ?? sortableKeys?.includes(id) ?? false;
-  const header = columnDef.header ?? getDefaultColumnHeader(key, options);
-  const cell = getCellFunction(schema, key, columnDef, options);
-  return {
-    ...columnDef,
-    id,
-    accessorKey: key,
-    meta: {
-      width: "flex-1",
-      ...options.globalMeta,
-      ...columnDef.meta
-    },
-    header,
-    enableSorting,
-    cell
-  };
-};
-const populateCustomColumnDef = (schema, key, columnDef, options, sortableKeys) => {
-  const id = columnDef.id ?? key;
-  const accessorKey = columnDef.accessorKey ?? id;
-  const enableSorting = columnDef.enableSorting ?? sortableKeys?.includes(id) ?? false;
-  const header = columnDef.header ?? getDefaultColumnHeader(key, options);
-  const cell = getCellFunction(schema, key, columnDef, options);
-  return {
-    ...columnDef,
-    id,
-    accessorKey,
-    meta: {
-      width: "flex-1",
-      ...options.globalMeta,
-      ...columnDef.meta
-    },
-    header,
-    enableSorting,
-    cell
-  };
-};
-const addMissingSchemaFields = (schema, existingColumns, options, sortableKeys) => {
-  const schemaFields = getAllSchemaKeys(schema);
-  const definedFields = new Set(existingColumns.map((col) => col.id));
-  const missingFields = schemaFields.filter((field) => !definedFields.has(field));
-  const additionalColumns = missingFields.map((field) => {
-    return populateColumnDef(schema, field, {}, options, sortableKeys);
-  });
-  return [...existingColumns, ...additionalColumns];
-};
-const removeOverriddenPresetColumns = (presetColumns, options) => {
-  if (presetColumns.length === 0) {
-    return presetColumns;
-  }
-  const usedColumnsIds = Object.entries(options.columns ?? {}).map(([key, value]) => {
-    const columnDef = value;
-    return columnDef.id ?? key;
-  });
-  const usedCustomColumnsIds = Object.entries(options.customColumns ?? {}).map(([key, value]) => {
-    const columnDef = value;
-    return columnDef.id ?? key;
-  });
-  const usedIds = [...usedColumnsIds, ...usedCustomColumnsIds];
-  return presetColumns.filter((column) => {
-    if (!column.id) {
-      return true;
-    }
-    return !usedIds.includes(column.id);
-  });
-};
-const getAllSchemaKeys = (schema) => {
-  const keys = [];
-  const { shape } = schema;
-  const traverse = (obj, prefix = "") => {
-    Object.entries(obj).forEach(([key, value]) => {
-      const currentPath = prefix ? `${prefix}.${key}` : key;
-      keys.push(currentPath);
-      if (value instanceof z.ZodObject) {
-        traverse(value.shape, currentPath);
-      }
-    });
-  };
-  traverse(shape);
-  return keys;
-};
-const validateCustomColumnKeys = (schema, customColumnKeys) => {
-  const schemaKeys = getAllSchemaKeys(schema);
-  const invalidCustomColumnKeys = customColumnKeys.filter(
-    (key) => schemaKeys.includes(key)
-  );
-  if (invalidCustomColumnKeys.length > 0) {
-    throw new Error(
-      `Invalid custom column keys: [${invalidCustomColumnKeys.join(", ")}]. Custom column keys cannot be part of the schema. Define these columns in the "columns" property instead.`
-    );
-  }
-};
-const validateOptionKeyArray = (usedKeys, optionKeys, optionName) => {
-  if (!optionKeys) {
-    return;
-  }
-  const extraUnusedKeys = optionKeys.filter((key) => !usedKeys.has(key));
-  if (extraUnusedKeys.length > 0) {
-    throw new Error(
-      `Found unnecessary keys in "${optionName}": [${extraUnusedKeys.join(", ")}].
-
-All available options are: [${Array.from(usedKeys).join(", ")}].`
-    );
-  }
-};
-const validateParams = (schema, presetColumns, options) => {
-  const { columns, customColumns, sortable, order, disableFormatting, includeAll } = options;
-  const columnKeys = Object.keys(columns ?? {});
-  const customColumnKeys = customColumns ? Object.keys(customColumns) : [];
-  const usedKeys = /* @__PURE__ */ new Set([...columnKeys, ...customColumnKeys]);
-  const presetKeys = presetColumns.map((column) => column.id).filter((id) => id !== void 0);
-  const schemaKeys = includeAll ? getAllSchemaKeys(schema) : [];
-  const allKeys = /* @__PURE__ */ new Set([...presetKeys, ...usedKeys, ...schemaKeys, "*"]);
-  if (customColumns) {
-    validateCustomColumnKeys(schema, customColumnKeys);
-  }
-  if (Array.isArray(sortable)) {
-    validateOptionKeyArray(usedKeys, sortable, "sortable");
-  }
-  validateOptionKeyArray(allKeys, order, "order");
-  validateOptionKeyArray(usedKeys, disableFormatting, "disableFormatting");
-};
-const dynamicColumns = ({
-  schema,
-  preset = [],
-  options
-}) => {
-  validateParams(schema, preset, options);
-  const sortableKeys = normalizeSortable(options.sortable);
-  let entries = Object.entries(options.columns ?? {});
-  entries = excludeEntries(entries);
-  entries = convertEntriesToColumnDefs(entries);
-  const columns = entries.map(([key, value]) => {
-    const columnDef = value;
-    return populateColumnDef(schema, key, columnDef, options, sortableKeys);
-  });
-  let customEntries = Object.entries(options.customColumns ?? {});
-  customEntries = convertCustomEntriesToColumnDefs(customEntries);
-  const customColumns = customEntries.map(([key, value]) => {
-    const columnDef = value;
-    return populateCustomColumnDef(schema, key, columnDef, options, sortableKeys);
-  });
-  let presetColumns = removeOverriddenPresetColumns(preset, options);
-  if (options.overridePresetLocales) {
-    presetColumns = overridePresetColumnsHeaders(presetColumns, options);
-  }
-  const mergedColumns = [...presetColumns, ...columns, ...customColumns];
-  const allColumns = options.includeAll ? addMissingSchemaFields(schema, mergedColumns, options, sortableKeys) : mergedColumns;
-  return sortColumns(allColumns, options.order);
-};
-export {
-  dynamicColumns,
-  sortColumns
-};