@unchainedshop/admin-ui 5.0.0-alpha.3 → 5.0.0-alpha.4

package/dist/chunk-BGCKJQGS.js

@@ -0,0 +1,58 @@
+import { createContext, useContext } from 'react';
+import 'react-intl';
+import { gql } from '@apollo/client';
+import '@apollo/client/react';
+import 'react/jsx-runtime';
+
+// src/modules/common/hooks/useApp.ts
+gql`
+  query ShopInfo {
+    shopInfo {
+      _id
+      version
+      language {
+        _id
+        isoCode
+        name
+      }
+      country {
+        _id
+        isoCode
+        flagEmoji
+        name
+        defaultCurrency {
+          _id
+          isoCode
+        }
+      }
+      adminUiConfig {
+        singleSignOnURL
+        externalLinks {
+          href
+          title
+          target
+        }
+        customProperties {
+          entityName
+          inlineFragment
+        }
+        productTags
+        assortmentTags
+        userTags
+      }
+    }
+  }
+`;
+var AppContext = createContext(void 0);
+var AppContext_default = AppContext;
+
+// src/modules/common/hooks/useApp.ts
+var useApp = () => {
+  const context = useContext(AppContext_default);
+  if (!context)
+    throw new Error("useLocale must be used within a LocaleProvider");
+  return context;
+};
+var useApp_default = useApp;
+
+export { useApp_default };

package/dist/chunk-BYXBJQAS.js

@@ -0,0 +1 @@
+

package/dist/chunk-EJDZRZSZ.js

@@ -0,0 +1,59 @@
+import { gql } from '@apollo/client';
+
+// src/modules/product/fragments/ProductBriefFragment.ts
+var ProductBriefFragment = gql`
+  fragment ProductBriefFragment on Product {
+    texts(forceLocale: $forceLocale) {
+      _id
+      slug
+      title
+      subtitle
+      description
+      vendor
+      brand
+      labels
+      locale
+    }
+    _id
+    sequence
+    status
+    tags
+    sequence
+    updated
+    published
+    media {
+      _id
+      tags
+      file {
+        _id
+        url
+      }
+    }
+    ... on BundleProduct {
+      proxies {
+        __typename
+      }
+    }
+    ... on SimpleProduct {
+      catalogPrice {
+        amount
+        currencyCode
+      }
+      proxies {
+        __typename
+      }
+    }
+    ... on PlanProduct {
+      catalogPrice {
+        amount
+        currencyCode
+      }
+      proxies {
+        __typename
+      }
+    }
+  }
+`;
+var ProductBriefFragment_default = ProductBriefFragment;
+
+export { ProductBriefFragment_default };

package/dist/chunk-ELPURWDC.js

@@ -0,0 +1,75 @@
+import { gql } from '@apollo/client';
+import { useQuery } from '@apollo/client/react';
+
+// src/modules/country/hooks/useCountries.ts
+var CountryFragment = gql`
+  fragment CountryFragment on Country {
+    _id
+    isoCode
+    isActive
+    isBase
+
+    defaultCurrency {
+      _id
+      isoCode
+    }
+  }
+`;
+var CountryFragment_default = CountryFragment;
+
+// src/modules/country/hooks/useCountries.ts
+var CountriesQuery = gql`
+  query Countries(
+    $queryString: String
+    $limit: Int
+    $offset: Int
+    $includeInactive: Boolean
+    $sort: [SortOptionInput!]
+  ) {
+    countries(
+      queryString: $queryString
+      limit: $limit
+      offset: $offset
+      includeInactive: $includeInactive
+      sort: $sort
+    ) {
+      ...CountryFragment
+    }
+    countriesCount(includeInactive: $includeInactive, queryString: $queryString)
+  }
+
+  ${CountryFragment_default}
+`;
+var useCountries = ({
+  queryString = "",
+  limit = 20,
+  offset = 0,
+  includeInactive = true,
+  sort = [],
+  skip = false
+} = {}) => {
+  const { data, loading, error, fetchMore } = useQuery(CountriesQuery, {
+    variables: { queryString, limit, offset, includeInactive, sort },
+    errorPolicy: "all",
+    skip
+  });
+  const countries = data?.countries || [];
+  const countriesCount = data?.countriesCount;
+  const hasMore = countries?.length < countriesCount;
+  const loadMore = () => {
+    fetchMore({
+      variables: { offset: countries?.length }
+    });
+  };
+  return {
+    countries,
+    countriesCount,
+    hasMore,
+    loading,
+    error,
+    loadMore
+  };
+};
+var useCountries_default = useCountries;
+
+export { CountryFragment_default, useCountries_default };

package/dist/chunk-IAQPLRXZ.js

@@ -0,0 +1,16 @@
+import React, { useContext } from 'react';
+
+// src/modules/UnchainedContext/useUnchainedContext.ts
+var UnchainedContext = React.createContext({
+  customProperties: {},
+  hydrateFragment: (fragment, data) => null
+});
+var UnchainedContext_default = UnchainedContext;
+
+// src/modules/UnchainedContext/useUnchainedContext.ts
+var useUnchainedContext = () => {
+  return useContext(UnchainedContext_default);
+};
+var useUnchainedContext_default = useUnchainedContext;
+
+export { useUnchainedContext_default };

package/dist/chunk-ILYPJE4N.js

@@ -0,0 +1,57 @@
+import { gql } from '@apollo/client';
+
+// src/modules/product-review/fragments/ProductReviewDetailFragment.ts
+var ProductReviewDetailFragment = gql`
+  fragment ProductReviewDetailFragment on ProductReview {
+    _id
+    created
+    updated
+    deleted
+    author {
+      _id
+      username
+      name
+      profile {
+        displayName
+        address {
+          firstName
+          lastName
+        }
+      }
+      isGuest
+      avatar {
+        _id
+
+        url
+      }
+    }
+    product {
+      _id
+      texts(forceLocale: $forceLocale) {
+        _id
+        title
+        subtitle
+      }
+      media {
+        _id
+        file {
+          _id
+          url
+        }
+      }
+    }
+    rating
+    title
+    review
+    upVote: voteCount(type: UPVOTE)
+    downVote: voteCount(type: DOWNVOTE)
+    voteReport: voteCount(type: REPORT)
+    ownVotes {
+      timestamp
+      type
+    }
+  }
+`;
+var ProductReviewDetailFragment_default = ProductReviewDetailFragment;
+
+export { ProductReviewDetailFragment_default };

package/dist/chunk-IXBMHOB5.js

@@ -0,0 +1,13 @@
+// src/modules/common/utils/getUniqueId.ts
+var parseUniqueId = (value) => {
+  if (!value) return null;
+  const slugAndId = value?.split("_id_");
+  return slugAndId?.pop();
+};
+var parseSlug = (value) => {
+  if (!value) return null;
+  const [slug] = value?.split("_id_") || [];
+  return slug;
+};
+
+export { parseSlug, parseUniqueId };

package/dist/chunk-KH5MK6ZW.js

@@ -0,0 +1,18 @@
+import { gql } from '@apollo/client';
+
+// src/modules/common/fragments/AddressFragment.ts
+var AddressFragment = gql`
+  fragment AddressFragment on Address {
+    firstName
+    lastName
+    company
+    addressLine
+    postalCode
+    city
+    countryCode
+    regionCode
+  }
+`;
+var AddressFragment_default = AddressFragment;
+
+export { AddressFragment_default };

package/dist/chunk-NT7RB7AK.js

@@ -0,0 +1,70 @@
+import { gql } from '@apollo/client';
+import { useQuery } from '@apollo/client/react';
+
+// src/modules/currency/hooks/useCurrencies.ts
+var CurrencyFragment = gql`
+  fragment CurrencyFragment on Currency {
+    _id
+    isoCode
+    isActive
+    contractAddress
+    decimals
+  }
+`;
+var CurrencyFragment_default = CurrencyFragment;
+
+// src/modules/currency/hooks/useCurrencies.ts
+var CurrenciesQuery = gql`
+  query Currencies(
+    $queryString: String
+    $limit: Int
+    $offset: Int
+    $includeInactive: Boolean
+    $sort: [SortOptionInput!]
+  ) {
+    currencies(
+      queryString: $queryString
+      limit: $limit
+      offset: $offset
+      includeInactive: $includeInactive
+      sort: $sort
+    ) {
+      ...CurrencyFragment
+    }
+    currenciesCount(
+      includeInactive: $includeInactive
+      queryString: $queryString
+    )
+  }
+  ${CurrencyFragment_default}
+`;
+var useCurrencies = ({
+  queryString = "",
+  limit = 20,
+  offset = 0,
+  includeInactive = true,
+  sort = []
+} = {}) => {
+  const { data, loading, error, fetchMore } = useQuery(CurrenciesQuery, {
+    variables: { queryString, limit, offset, includeInactive, sort }
+  });
+  const currencies = data?.currencies || [];
+  const currenciesCount = data?.currenciesCount;
+  const hasMore = currencies?.length < currenciesCount;
+  const loadMore = () => {
+    fetchMore({
+      variables: { offset: currencies?.length }
+    });
+  };
+  return {
+    currencies,
+    currenciesCount,
+    hasMore,
+    loading,
+    error,
+    loadMore
+  };
+};
+var useCurrencies_default = useCurrencies;
+
+export { CurrencyFragment_default, useCurrencies_default };

package/dist/chunk-OKGJ6HDE.js

@@ -0,0 +1,26 @@
+import { gql } from '@apollo/client';
+
+// src/modules/filter/fragments/FilterFragment.ts
+var FilterFragment = gql`
+  fragment FilterFragment on Filter {
+    _id
+    updated
+    created
+    key
+    isActive
+    type
+    options {
+      _id
+      texts {
+        _id
+        title
+        subtitle
+        locale
+      }
+      value
+    }
+  }
+`;
+var FilterFragment_default = FilterFragment;
+
+export { FilterFragment_default };

package/dist/chunk-Q6S3LBUF.js

@@ -0,0 +1,180 @@
+import { useState, useCallback, useMemo } from 'react';
+import { useForm as useForm$1 } from 'react-hook-form';
+import { useIntl } from 'react-intl';
+import { toast } from 'react-toastify';
+
+// src/modules/forms/hooks/useForm.ts
+
+// src/modules/common/utils/normalizeFilterKeys.ts
+var isObject = (obj) => {
+  return Object.prototype.toString.call(obj) === "[object Object]";
+};
+
+// src/modules/forms/lib/clean.ts
+var sanitize = (value) => {
+  if (value === "" || typeof value === "string" && value?.trim() === "")
+    return null;
+  if (typeof value === "string" && value.length) return value.trim();
+  if (Array.isArray(value) && value?.length && typeof value[0] === "string")
+    return value.map((v) => sanitize(v));
+  if (Array.isArray(value) && value?.length && isObject(value[0]))
+    return value.map(
+      (v) => Object.fromEntries(
+        Object.entries(v).map(([name, val]) => [name, sanitize(val)])
+      )
+    );
+  return value;
+};
+var clean = (values) => Object.fromEntries(
+  Object.entries(values).map(([name, value]) => [name, sanitize(value)])
+);
+var clean_default = clean;
+
+// src/modules/forms/hooks/useForm.ts
+var stripToMessages = (errors) => {
+  if (!errors || typeof errors !== "object") return errors;
+  if (typeof errors.message === "string" && errors.message)
+    return errors.message;
+  if (Array.isArray(errors)) return errors.map((v) => stripToMessages(v));
+  return Object.fromEntries(
+    Object.entries(errors).filter(([k]) => k !== "ref").map(([k, v]) => [k, stripToMessages(v)])
+  );
+};
+var useForm = ({
+  submit,
+  getSubmitErrorMessage = () => "",
+  onSubmitSuccess = () => true,
+  initialValues,
+  initialErrors,
+  initialTouched,
+  successMessage,
+  enableReinitialize,
+  validate,
+  disabled = false
+}) => {
+  const intl = useIntl();
+  const [submitError, setSubmitError] = useState("");
+  const rhf = useForm$1({
+    mode: "onTouched",
+    defaultValues: initialValues,
+    values: enableReinitialize ? initialValues : void 0,
+    errors: initialErrors ? Object.fromEntries(
+      Object.entries(initialErrors).map(([key, message]) => [
+        key,
+        { type: "manual", message }
+      ])
+    ) : void 0
+  });
+  const parseError = useCallback(
+    (combinedError) => {
+      const error = combinedError?.errors?.[0];
+      return intl.formatMessage(
+        {
+          id: "error_server",
+          defaultMessage: "{details}"
+        },
+        { details: error?.message || "" }
+      );
+    },
+    [intl]
+  );
+  const onSubmit = useCallback(
+    async (values) => {
+      let reset = true;
+      try {
+        const result = await submit(clean_default(values));
+        const success = (typeof result === "boolean" ? result : result?.success) ?? !result?.error;
+        if (success) {
+          if (successMessage) toast.success(successMessage);
+          await onSubmitSuccess(success, result?.data || values);
+        } else {
+          const errors = typeof result === "boolean" ? !result : result?.error;
+          if (Array.isArray(errors)) {
+            errors.forEach((error) => {
+              reset = false;
+              setSubmitError(getSubmitErrorMessage(error) || parseError(error));
+            });
+          } else if (typeof errors === "string") {
+            reset = false;
+            setSubmitError(getSubmitErrorMessage(errors) || parseError(errors));
+          } else if (typeof errors === "object" && errors !== null) {
+            reset = false;
+            setSubmitError(getSubmitErrorMessage(errors) || parseError(errors));
+          } else {
+            reset = false;
+            setSubmitError(getSubmitErrorMessage(errors) || parseError(errors));
+          }
+        }
+      } catch (error) {
+        reset = false;
+        setSubmitError(getSubmitErrorMessage(error) || parseError(error));
+      }
+      if (reset) {
+        setSubmitError("");
+      }
+    },
+    [
+      submit,
+      successMessage,
+      onSubmitSuccess,
+      getSubmitErrorMessage,
+      parseError
+    ]
+  );
+  const api = useMemo(
+    () => ({
+      setFieldError: (name, message) => {
+        rhf.setError(name, { type: "manual", message });
+      },
+      setFieldValue: (name, value) => {
+        rhf.setValue(name, value, { shouldDirty: true, shouldTouch: true });
+      },
+      setValues: (values) => {
+        rhf.reset(values, { keepDirtyValues: false, keepErrors: false });
+      },
+      get values() {
+        return rhf.getValues();
+      },
+      get isValid() {
+        return rhf.formState.isValid;
+      },
+      get isSubmitting() {
+        return rhf.formState.isSubmitting;
+      },
+      handleSubmit: rhf.handleSubmit(onSubmit),
+      handleReset: () => {
+        rhf.reset();
+      },
+      resetForm: (nextValues) => {
+        rhf.reset(nextValues || initialValues);
+      },
+      submitForm: () => {
+        rhf.handleSubmit(onSubmit)();
+      },
+      getFieldMeta: (name) => {
+        const fieldState = rhf.getFieldState(name, rhf.formState);
+        return {
+          error: fieldState.error?.message,
+          touched: fieldState.isTouched
+        };
+      },
+      get initialValues() {
+        return initialValues;
+      },
+      get errors() {
+        return stripToMessages(rhf.formState.errors);
+      }
+    }),
+    [rhf, onSubmit, initialValues]
+  );
+  return {
+    submitError,
+    api,
+    rhf,
+    setSubmitError,
+    disabled
+  };
+};
+var useForm_default = useForm;
+
+export { useForm_default };

package/dist/chunk-QNLGYFV7.js

@@ -0,0 +1,22 @@
+import { gql } from '@apollo/client';
+
+// src/modules/product/fragments/TokenFragment.ts
+var TokenFragment = gql`
+  fragment TokenFragment on Token {
+    _id
+    walletAddress
+    status
+    quantity
+    contractAddress
+    chainId
+    tokenSerialNumber
+    invalidatedDate
+    expiryDate
+    ercMetadata
+    accessKey
+    isInvalidateable
+  }
+`;
+var TokenFragment_default = TokenFragment;
+
+export { TokenFragment_default };

package/dist/chunk-RAQV2GYF.js

@@ -0,0 +1,70 @@
+import { gql } from '@apollo/client';
+import { useQuery } from '@apollo/client/react';
+
+// src/modules/language/hooks/useLanguages.ts
+var LanguageFragment = gql`
+  fragment LanguageFragment on Language {
+    _id
+    isoCode
+    isActive
+    isBase
+    name
+  }
+`;
+var LanguageFragment_default = LanguageFragment;
+
+// src/modules/language/hooks/useLanguages.ts
+var LanguagesQuery = gql`
+  query Languages(
+    $queryString: String
+    $offset: Int
+    $limit: Int
+    $includeInactive: Boolean
+    $sort: [SortOptionInput!]
+  ) {
+    languages(
+      queryString: $queryString
+      offset: $offset
+      limit: $limit
+      includeInactive: $includeInactive
+      sort: $sort
+    ) {
+      ...LanguageFragment
+    }
+    languagesCount(includeInactive: $includeInactive, queryString: $queryString)
+  }
+  ${LanguageFragment_default}
+`;
+var useLanguages = ({
+  queryString = "",
+  limit = 20,
+  offset = 0,
+  includeInactive = true,
+  sort = [],
+  skip = false
+} = {}) => {
+  const { data, loading, error, fetchMore } = useQuery(LanguagesQuery, {
+    variables: { queryString, limit, offset, includeInactive, sort },
+    errorPolicy: "all",
+    skip
+  });
+  const languages = data?.languages || [];
+  const languagesCount = data?.languagesCount;
+  const hasMore = languages?.length < languagesCount;
+  const loadMore = () => {
+    fetchMore({
+      variables: { offset: languages?.length }
+    });
+  };
+  return {
+    languages,
+    languagesCount,
+    hasMore,
+    loading,
+    error,
+    loadMore
+  };
+};
+var useLanguages_default = useLanguages;
+
+export { LanguageFragment_default, useLanguages_default };