@unchainedshop/admin-ui 4.8.19 → 4.8.20

package/dist/modules/quotation.js

@@ -0,0 +1,297 @@
+import { useUnchainedContext_default } from '../chunk-IAQPLRXZ.js';
+import '../chunk-4VNS5WPM.js';
+import { gql } from '@apollo/client';
+import { useMutation, useQuery } from '@apollo/client/react';
+
+var QuotationDetailFragment = gql`
+  fragment QuotationDetailFragment on Quotation {
+    _id
+    user {
+      _id
+      username
+      avatar {
+        _id
+        url
+      }
+      name
+      primaryEmail {
+        verified
+        address
+      }
+    }
+    configuration {
+      key
+      value
+    }
+    country {
+      _id
+      isoCode
+      flagEmoji
+      name
+    }
+    currency {
+      _id
+      isoCode
+      isActive
+    }
+    product {
+      _id
+      texts {
+        _id
+        slug
+        subtitle
+        title
+        description
+      }
+      media {
+        _id
+        file {
+          _id
+          type
+          url
+        }
+      }
+    }
+    status
+    created
+    expires
+    updated
+    isExpired
+    quotationNumber
+    fulfilled
+    rejected
+  }
+`;
+var QuotationDetailFragment_default = QuotationDetailFragment;
+
+// src/modules/quotation/hooks/useMakeQuotationProposal.ts
+var MakeQuotationProposalMutation = gql`
+  mutation MakeQuotationProposal($quotationId: ID!, $quotationContext: JSON) {
+    makeQuotationProposal(
+      quotationId: $quotationId
+      quotationContext: $quotationContext
+    ) {
+      ...QuotationDetailFragment
+    }
+  }
+  ${QuotationDetailFragment_default}
+`;
+var useMakeQuotationProposal = () => {
+  const [makeQuotationProposalMutation] = useMutation(MakeQuotationProposalMutation);
+  const makeQuotationProposal = async ({
+    quotationId = null,
+    quotationContext = {}
+  }) => {
+    return makeQuotationProposalMutation({
+      variables: { quotationId, quotationContext }
+    });
+  };
+  return {
+    makeQuotationProposal
+  };
+};
+var useMakeQuotationProposal_default = useMakeQuotationProposal;
+var GetQuotationsQuery = (inlineFragment = "") => gql`
+  query Quotation($quotationId: ID!) {
+    quotation(quotationId: $quotationId) {
+      _id
+      ...QuotationDetailFragment
+      ${inlineFragment}
+    }
+    quotationsCount
+  }
+  ${QuotationDetailFragment_default}
+`;
+var useQuotation = ({ quotationId }) => {
+  const { customProperties } = useUnchainedContext_default();
+  const { data, loading, error } = useQuery(GetQuotationsQuery(customProperties?.Quotation), {
+    skip: !quotationId,
+    variables: { quotationId }
+  });
+  return {
+    quotation: data?.quotation,
+    loading,
+    error
+  };
+};
+var useQuotation_default = useQuotation;
+var QuotationFragment = gql`
+  fragment QuotationFragment on Quotation {
+    _id
+    user {
+      _id
+      username
+      avatar {
+        _id
+        url
+      }
+      name
+      primaryEmail {
+        verified
+        address
+      }
+    }
+    product {
+      _id
+      texts {
+        _id
+        slug
+        subtitle
+        title
+        description
+      }
+      media {
+        _id
+        file {
+          _id
+          type
+          url
+        }
+      }
+    }
+    currency {
+      _id
+      contractAddress
+      decimals
+      isoCode
+    }
+    status
+    created
+    expires
+    updated
+    isExpired
+    quotationNumber
+    fulfilled
+    rejected
+  }
+`;
+var QuotationFragment_default = QuotationFragment;
+
+// src/modules/quotation/hooks/useQuotations.ts
+var QuotationsQuery = gql`
+  query Quotations(
+    $limit: Int
+    $offset: Int
+    $queryString: String
+    $sort: [SortOptionInput!]
+  ) {
+    quotations(
+      limit: $limit
+      offset: $offset
+      queryString: $queryString
+      sort: $sort
+    ) {
+      ...QuotationFragment
+    }
+    quotationsCount(queryString: $queryString)
+  }
+  ${QuotationFragment_default}
+`;
+var useQuotations = ({
+  limit = 20,
+  offset = 0,
+  queryString = "",
+  sort = []
+} = {}) => {
+  const { data, loading, error, fetchMore } = useQuery(QuotationsQuery, {
+    variables: { limit, offset, queryString, sort }
+  });
+  const quotations = data?.quotations || [];
+  const quotationsCount = data?.quotationsCount;
+  const hasMore = quotations?.length < quotationsCount;
+  const loadMore = () => {
+    fetchMore({
+      variables: { offset: quotations?.length }
+    });
+  };
+  return {
+    quotations,
+    quotationsCount,
+    hasMore,
+    loading,
+    error,
+    loadMore
+  };
+};
+var useQuotations_default = useQuotations;
+var RejectQuotationMutation = gql`
+  mutation RejectQuotation($quotationId: ID!, $quotationContext: JSON) {
+    rejectQuotation(
+      quotationId: $quotationId
+      quotationContext: $quotationContext
+    ) {
+      ...QuotationDetailFragment
+    }
+  }
+  ${QuotationDetailFragment_default}
+`;
+var useRejectQuotation = () => {
+  const [rejectQuotationMutation] = useMutation(RejectQuotationMutation);
+  const rejectQuotation = async ({
+    quotationId = null,
+    quotationContext = {}
+  }) => {
+    return rejectQuotationMutation({
+      variables: { quotationId, quotationContext }
+    });
+  };
+  return {
+    rejectQuotation
+  };
+};
+var useRejectQuotation_default = useRejectQuotation;
+var UserQuotationsQuery = gql`
+  query UserQuotations($userId: ID!, $queryString: String) {
+    user(userId: $userId) {
+      _id
+      quotations(queryString: $queryString) {
+        ...QuotationFragment
+      }
+    }
+  }
+  ${QuotationFragment_default}
+`;
+var useUserQuotations = ({
+  userId = null,
+  queryString = ""
+}) => {
+  const { data, loading, error } = useQuery(UserQuotationsQuery, {
+    skip: !userId,
+    variables: { userId, queryString }
+  });
+  const quotations = data?.user?.quotations || [];
+  return {
+    quotations,
+    loading,
+    error
+  };
+};
+var useUserQuotations_default = useUserQuotations;
+var VerifyQuotationMutation = gql`
+  mutation VerifyQuotation($quotationId: ID!, $quotationContext: JSON) {
+    verifyQuotation(
+      quotationId: $quotationId
+      quotationContext: $quotationContext
+    ) {
+      ...QuotationDetailFragment
+    }
+  }
+  ${QuotationDetailFragment_default}
+`;
+var useVerifyQuotation = () => {
+  const [verifyQuotationMutation] = useMutation(VerifyQuotationMutation);
+  const VerifyQuotation = async ({
+    quotationId = null,
+    quotationContext = {}
+  }) => {
+    return verifyQuotationMutation({
+      variables: { quotationId, quotationContext }
+    });
+  };
+  return {
+    VerifyQuotation
+  };
+};
+var useVerifyQuotation_default = useVerifyQuotation;
+
+export { useMakeQuotationProposal_default as useMakeQuotationProposal, useQuotation_default as useQuotation, useQuotations_default as useQuotations, useRejectQuotation_default as useRejectQuotation, useUserQuotations_default as useUserQuotations, useVerifyQuotation_default as useVerifyQuotation };

package/dist/modules/token.js

@@ -0,0 +1,143 @@
+import { TokenFragment_default } from '../chunk-QNLGYFV7.js';
+import { ProductBriefFragment_default } from '../chunk-EJDZRZSZ.js';
+import { DefaultLimit } from '../chunk-VDKQGOMV.js';
+import '../chunk-4VNS5WPM.js';
+import { gql } from '@apollo/client';
+import { useMutation, useQuery } from '@apollo/client/react';
+
+var InvalidateTokenMutation = gql`
+  mutation InvalidateToken($tokenId: ID!) {
+    invalidateToken(tokenId: $tokenId) {
+      ...TokenFragment
+    }
+  }
+  ${TokenFragment_default}
+`;
+var useInvalidateTicket = () => {
+  const [invalidateTokenMutation] = useMutation(InvalidateTokenMutation);
+  const invalidateTicket = async ({ tokenId }) => {
+    const result = await invalidateTokenMutation({
+      variables: { tokenId },
+      refetchQueries: ["Tokens", "Token"]
+    });
+    return result;
+  };
+  return { invalidateTicket };
+};
+var useInvalidateTicket_default = useInvalidateTicket;
+var TokenQuery = gql`
+  query Token($tokenId: ID!, $forceLocale: Locale) {
+    token(tokenId: $tokenId) {
+      ...TokenFragment
+      product {
+        ...ProductBriefFragment
+        simulatedPrice {
+          amount
+          currencyCode
+        }
+      }
+      user {
+        _id
+        username
+        isGuest
+        avatar {
+          _id
+          url
+        }
+        name
+        primaryEmail {
+          verified
+          address
+        }
+        lastContact {
+          telNumber
+          emailAddress
+        }
+        profile {
+          displayName
+          address {
+            firstName
+            lastName
+          }
+        }
+      }
+    }
+  }
+  ${TokenFragment_default}
+  ${ProductBriefFragment_default}
+`;
+var useToken = ({ tokenId }) => {
+  const { data, loading, error } = useQuery(
+    TokenQuery,
+    {
+      variables: { tokenId }
+    }
+  );
+  return {
+    token: data?.token,
+    loading,
+    error
+  };
+};
+var useToken_default = useToken;
+var TokensQuery = gql`
+  query Tokens(
+    $queryString: String
+    $limit: Int
+    $offset: Int
+    $forceLocale: Locale
+  ) {
+    tokens(queryString: $queryString, limit: $limit, offset: $offset) {
+      ...TokenFragment
+      product {
+        ...ProductBriefFragment
+        simulatedPrice {
+          amount
+          currencyCode
+        }
+      }
+      user {
+        _id
+        username
+        isGuest
+        primaryEmail {
+          address
+          verified
+        }
+        avatar {
+          _id
+          url
+        }
+        profile {
+          displayName
+          address {
+            firstName
+            lastName
+          }
+        }
+      }
+    }
+    tokensCount(queryString: $queryString)
+  }
+  ${TokenFragment_default}
+  ${ProductBriefFragment_default}
+`;
+var useTokens = ({
+  queryString = null,
+  limit = DefaultLimit,
+  offset = 0
+}) => {
+  const { data, loading, error } = useQuery(TokensQuery, {
+    variables: { queryString, limit, offset }
+  });
+  const tokens = data?.tokens || [];
+  return {
+    tokens,
+    loading,
+    error,
+    tokensCount: data?.tokensCount || 0
+  };
+};
+var useTokens_default = useTokens;
+
+export { useInvalidateTicket_default as useInvalidateTicket, useToken_default as useToken, useTokens_default as useTokens };

package/dist/modules/warehousing-providers.js

@@ -0,0 +1,206 @@
+import { useUnchainedContext_default } from '../chunk-IAQPLRXZ.js';
+import '../chunk-4VNS5WPM.js';
+import { gql } from '@apollo/client';
+import { useMutation, useQuery } from '@apollo/client/react';
+
+var WarehousingProviderFragment = gql`
+  fragment WarehousingProviderFragment on WarehousingProvider {
+    _id
+    created
+    updated
+    deleted
+    isActive
+    type
+    interface {
+      _id
+      label
+      version
+    }
+    configuration
+    configurationError
+  }
+`;
+var WarehousingProviderFragment_default = WarehousingProviderFragment;
+
+// src/modules/warehousing-providers/hooks/useCreateWarehousingProvider.ts
+var CreateWarehousingProviderMutation = gql`
+  mutation CreateWarehousingProvider(
+    $warehousingProvider: CreateWarehousingProviderInput!
+  ) {
+    createWarehousingProvider(warehousingProvider: $warehousingProvider) {
+      ...WarehousingProviderFragment
+    }
+  }
+  ${WarehousingProviderFragment_default}
+`;
+var useCreateWarehousingProvider = () => {
+  const [createWarehousingProviderMutation, { data, loading, error }] = useMutation(CreateWarehousingProviderMutation);
+  const createWarehousingProvider = async ({
+    warehousingProvider: { adapterKey, type }
+  }) => {
+    return createWarehousingProviderMutation({
+      variables: { warehousingProvider: { adapterKey, type } },
+      refetchQueries: ["WarehousingProviders", "ShopStatus"]
+    });
+  };
+  const newWarehousingProvider = data?.createWarehousingProvider;
+  return {
+    createWarehousingProvider,
+    newWarehousingProvider,
+    loading,
+    error
+  };
+};
+var useCreateWarehousingProvider_default = useCreateWarehousingProvider;
+var RemoveWarehousingProviderMutation = gql`
+  mutation RemoveWarehousingProvider($warehousingProviderId: ID!) {
+    removeWarehousingProvider(warehousingProviderId: $warehousingProviderId) {
+      _id
+    }
+  }
+`;
+var useRemoveWarehousingProvider = () => {
+  const [removeWarehousingProviderMutation] = useMutation(RemoveWarehousingProviderMutation);
+  const removeWarehousingProvider = async ({
+    warehousingProviderId
+  }) => {
+    return removeWarehousingProviderMutation({
+      variables: {
+        warehousingProviderId
+      },
+      refetchQueries: ["WarehousingProviders", "ShopStatus"]
+    });
+  };
+  return {
+    removeWarehousingProvider
+  };
+};
+var useRemoveWarehousingProvider_default = useRemoveWarehousingProvider;
+var UpdateWarehousingProviderMutation = gql`
+  mutation UpdateWarehousingProvider(
+    $warehousingProvider: UpdateProviderInput!
+    $warehousingProviderId: ID!
+  ) {
+    updateWarehousingProvider(
+      warehousingProvider: $warehousingProvider
+      warehousingProviderId: $warehousingProviderId
+    ) {
+      ...WarehousingProviderFragment
+    }
+  }
+  ${WarehousingProviderFragment_default}
+`;
+var useUpdateWarehousingProvider = () => {
+  const [updateWarehousingProviderMutation] = useMutation(UpdateWarehousingProviderMutation);
+  const updateWarehousingProvider = async ({
+    warehousingProvider: { configuration },
+    warehousingProviderId
+  }) => {
+    return updateWarehousingProviderMutation({
+      variables: {
+        warehousingProvider: { configuration },
+        warehousingProviderId
+      }
+    });
+  };
+  return {
+    updateWarehousingProvider
+  };
+};
+var useUpdateWarehousingProvider_default = useUpdateWarehousingProvider;
+var WarehousingInterfacesQuery = gql`
+  query WarehousingInterfaces($providerType: WarehousingProviderType) {
+    warehousingInterfaces(type: $providerType) {
+      _id
+      value: _id
+      label
+    }
+  }
+`;
+var useWarehousingInterfacesByType = ({
+  providerType
+}) => {
+  const { data, loading, error } = useQuery(WarehousingInterfacesQuery, {
+    skip: !providerType,
+    variables: { providerType }
+  });
+  const warehousingInterfaces = data?.warehousingInterfaces || [];
+  return {
+    warehousingInterfaces,
+    loading,
+    error
+  };
+};
+var useWarehousingInterfacesByType_default = useWarehousingInterfacesByType;
+var GetWarehousingProviderQuery = (inlineFragment = "") => gql`
+  query WarehousingProvider($warehousingProviderId: ID!) {
+    warehousingProvider(warehousingProviderId: $warehousingProviderId) {
+      ...WarehousingProviderFragment
+      ${inlineFragment}
+    }
+  }
+  ${WarehousingProviderFragment_default}
+`;
+var useWarehousingProvider = ({
+  warehousingProviderId = null
+}) => {
+  const { customProperties } = useUnchainedContext_default();
+  const { data, loading, error } = useQuery(GetWarehousingProviderQuery(customProperties?.WarehousingProvider), {
+    skip: !warehousingProviderId,
+    variables: { warehousingProviderId }
+  });
+  return {
+    warehousingProvider: data?.warehousingProvider,
+    loading,
+    error
+  };
+};
+var useWarehousingProvider_default = useWarehousingProvider;
+var WarehousingProvidersTypeQuery = gql`
+  query WarehousingProvidersType {
+    warehousingProviderType: __type(name: "WarehousingProviderType") {
+      options: enumValues {
+        value: name
+        label: description
+      }
+    }
+  }
+`;
+var useWarehousingProviderTypes = () => {
+  const { data, loading, error } = useQuery(WarehousingProvidersTypeQuery);
+  const warehousingProviderType = data?.warehousingProviderType?.options || [];
+  return {
+    warehousingProviderType,
+    loading,
+    error
+  };
+};
+var useWarehousingProviderTypes_default = useWarehousingProviderTypes;
+var WarehousingProvidersQuery = gql`
+  query WarehousingProviders($type: WarehousingProviderType) {
+    warehousingProviders(type: $type) {
+      ...WarehousingProviderFragment
+    }
+    warehousingProvidersCount(type: $type)
+  }
+  ${WarehousingProviderFragment_default}
+`;
+var useWarehousingProviders = ({
+  type = null
+} = {}) => {
+  const variables = {};
+  if (type) variables.type = type;
+  const { data, loading, error } = useQuery(WarehousingProvidersQuery, {
+    variables
+  });
+  const warehousingProviders = data?.warehousingProviders || [];
+  return {
+    warehousingProviders,
+    loading,
+    error,
+    warehousingProvidersCount: data?.warehousingProvidersCount || 0
+  };
+};
+var useWarehousingProviders_default = useWarehousingProviders;
+
+export { useCreateWarehousingProvider_default as useCreateWarehousingProvider, useRemoveWarehousingProvider_default as useRemoveWarehousingProvider, useUpdateWarehousingProvider_default as useUpdateWarehousingProvider, useWarehousingInterfacesByType_default as useWarehousingInterfacesByType, useWarehousingProvider_default as useWarehousingProvider, useWarehousingProviderTypes_default as useWarehousingProviderTypes, useWarehousingProviders_default as useWarehousingProviders };

package/dist/modules/work/fragments/WorkFragment.d.ts

@@ -0,0 +1,3 @@
+declare const WorkFragment: import("graphql").DocumentNode;
+export default WorkFragment;
+//# sourceMappingURL=WorkFragment.d.ts.map

package/dist/modules/work/fragments/WorkFragment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WorkFragment.d.ts","sourceRoot":"","sources":["../../../../src/modules/work/fragments/WorkFragment.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,YAAY,gCAmBjB,CAAC;AAEF,eAAe,YAAY,CAAC"}

package/dist/modules/work/hooks/useAddWork.d.ts

@@ -0,0 +1,6 @@
+import { IAddWorkMutation, IAddWorkMutationVariables } from '../../../gql/types';
+declare const useAddWork: () => {
+    addWork: ({ type, priority, input, originalWorkId, scheduled, retries, }: IAddWorkMutationVariables) => Promise<import("@apollo/client").ApolloClient.MutateResult<IAddWorkMutation, undefined>>;
+};
+export default useAddWork;
+//# sourceMappingURL=useAddWork.d.ts.map

package/dist/modules/work/hooks/useAddWork.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAddWork.d.ts","sourceRoot":"","sources":["../../../../src/modules/work/hooks/useAddWork.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,gBAAgB,EAChB,yBAAyB,EAC1B,MAAM,oBAAoB,CAAC;AAwB5B,QAAA,MAAM,UAAU;8EAaX,yBAAyB;CAiB7B,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/modules/work/hooks/useWork.d.ts

@@ -0,0 +1,32 @@
+import { IWorkQueryVariables } from '../../../gql/types';
+export declare const GetWorkQuery: (inlineFragment?: string) => import("graphql").DocumentNode;
+declare const useWork: ({ workId, ...options }: IWorkQueryVariables & {
+    pollInterval?: number;
+}) => {
+    work: {
+        error?: any | null;
+        priority: number;
+        worker?: string | null;
+        timeout?: number | null;
+        _id: string;
+        type: import("../../../gql/types").IWorkType;
+        scheduled?: any | null;
+        status: import("../../../gql/types").IWorkStatus;
+        started?: any | null;
+        success?: boolean | null;
+        finished?: any | null;
+        created: any;
+        deleted?: any | null;
+        retries: number;
+        input?: any | null;
+        result?: any | null;
+        original?: {
+            _id: string;
+            retries: number;
+        } | null;
+    };
+    loading: boolean;
+    error: import("@apollo/client").ErrorLike;
+};
+export default useWork;
+//# sourceMappingURL=useWork.d.ts.map

package/dist/modules/work/hooks/useWork.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useWork.d.ts","sourceRoot":"","sources":["../../../../src/modules/work/hooks/useWork.ts"],"names":[],"mappings":"AAEA,OAAO,EAAc,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAIrE,eAAO,MAAM,YAAY,GAAI,uBAAmB,mCAY/C,CAAC;AAEF,QAAA,MAAM,OAAO,GAAI,wBAGd,mBAAmB,GAAG;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;CAgBjD,CAAC;AAEF,eAAe,OAAO,CAAC"}