@teamnovu/kit-shopware-composables 0.0.3 → 0.0.4

package/dist/query/products/useReadCategoryListQuery.d.ts

@@ -0,0 +1,48 @@
+import { OperationOptions } from '../types/query';
+import { UndefinedInitialQueryOptions, UseQueryReturnType } from '@tanstack/vue-query';
+import { components, GenericRecord } from '../../../api-types/storeApiTypes';
+declare const readCategoryListOperation = "readCategoryList post /category";
+export declare const useReadCategoryListQueryOptions: (options?: OperationOptions<typeof readCategoryListOperation>) => UndefinedInitialQueryOptions<{
+    elements?: components["schemas"]["Category"][];
+} & {
+    aggregations?: GenericRecord[];
+    entity?: string;
+    limit?: number;
+    page?: number;
+    total?: number;
+}, Error, {
+    elements?: components["schemas"]["Category"][];
+} & {
+    aggregations?: GenericRecord[];
+    entity?: string;
+    limit?: number;
+    page?: number;
+    total?: number;
+}, readonly ["category", "list", {
+    readonly body: unknown;
+}]> & {
+    queryKey: readonly ["category", "list", {
+        readonly body: unknown;
+    }] & {
+        [dataTagSymbol]: {
+            elements?: components["schemas"]["Category"][];
+        } & {
+            aggregations?: GenericRecord[];
+            entity?: string;
+            limit?: number;
+            page?: number;
+            total?: number;
+        };
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function useReadCategoryListQuery(options?: OperationOptions<typeof readCategoryListOperation>): UseQueryReturnType<{
+    elements?: components["schemas"]["Category"][];
+} & {
+    aggregations?: GenericRecord[];
+    entity?: string;
+    limit?: number;
+    page?: number;
+    total?: number;
+}, Error>;
+export {};

package/dist/query/products/useReadCompactProductListingQuery.d.ts

@@ -0,0 +1,35 @@
+import { MaybeRef } from 'vue';
+import { OperationOptions } from '../types/query';
+import { UndefinedInitialQueryOptions, UseQueryReturnType } from '@tanstack/vue-query';
+import { components } from '../../../api-types/storeApiTypes';
+declare const readListingOperation = "readCompactProductListing post /novu/headless/product-listing/{seoUrl}";
+export declare function useReadCompactProductListingQueryOptions(seoUrl: MaybeRef<string>, options?: OperationOptions<typeof readListingOperation, 'params'>): UndefinedInitialQueryOptions<{
+    apiAlias: "novuProductListing";
+    category: components["schemas"]["Category"];
+    listing: components["schemas"]["ProductListingResult"];
+}, Error, {
+    apiAlias: "novuProductListing";
+    category: components["schemas"]["Category"];
+    listing: components["schemas"]["ProductListingResult"];
+}, readonly ["product", "list", {
+    readonly url: MaybeRef<string>;
+    readonly body: unknown;
+}]> & {
+    queryKey: readonly ["product", "list", {
+        readonly url: MaybeRef<string>;
+        readonly body: unknown;
+    }] & {
+        [dataTagSymbol]: {
+            apiAlias: "novuProductListing";
+            category: components["schemas"]["Category"];
+            listing: components["schemas"]["ProductListingResult"];
+        };
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function useReadCompactProductListingQuery(seoUrl: MaybeRef<string>, options?: OperationOptions<typeof readListingOperation, 'params'>): UseQueryReturnType<{
+    apiAlias: "novuProductListing";
+    category: components["schemas"]["Category"];
+    listing: components["schemas"]["ProductListingResult"];
+}, Error>;
+export {};

package/dist/query/products/useReadCustomProductDetailQuery.d.ts

@@ -0,0 +1,67 @@
+import { MaybeRef } from 'vue';
+import { OperationOptions } from '../types/query';
+import { UndefinedInitialQueryOptions, UseQueryReturnType } from '@tanstack/vue-query';
+import { components, GenericRecord } from '../../../api-types/storeApiTypes';
+declare const readCustomProductDetailOperation = "readCustomProductDetail post /novu/headless/product/{seoUrl}";
+export declare function useReadCustomProductDetailOptions(seoUrl: MaybeRef<string>, body?: OperationOptions<typeof readCustomProductDetailOperation, 'params'>): UndefinedInitialQueryOptions<{
+    apiAlias: "product_detail";
+    configurator: components["schemas"]["PropertyGroup"][];
+    cross_sellings: components["schemas"]["CrossSellingElementCollection"];
+    custom_fields: GenericRecord;
+    product: components["schemas"]["Product"] & {
+        extensions?: {
+            novuSeoUrls?: GenericRecord;
+            search?: GenericRecord;
+            variants?: components["schemas"]["Product"][];
+        };
+    };
+}, Error, {
+    apiAlias: "product_detail";
+    configurator: components["schemas"]["PropertyGroup"][];
+    cross_sellings: components["schemas"]["CrossSellingElementCollection"];
+    custom_fields: GenericRecord;
+    product: components["schemas"]["Product"] & {
+        extensions?: {
+            novuSeoUrls?: GenericRecord;
+            search?: GenericRecord;
+            variants?: components["schemas"]["Product"][];
+        };
+    };
+}, readonly ["product", "detail", {
+    readonly url: MaybeRef<string>;
+    readonly body: unknown;
+}]> & {
+    queryKey: readonly ["product", "detail", {
+        readonly url: MaybeRef<string>;
+        readonly body: unknown;
+    }] & {
+        [dataTagSymbol]: {
+            apiAlias: "product_detail";
+            configurator: components["schemas"]["PropertyGroup"][];
+            cross_sellings: components["schemas"]["CrossSellingElementCollection"];
+            custom_fields: GenericRecord;
+            product: components["schemas"]["Product"] & {
+                extensions?: {
+                    novuSeoUrls?: GenericRecord;
+                    search?: GenericRecord;
+                    variants?: components["schemas"]["Product"][];
+                };
+            };
+        };
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function useReadCustomProductDetailQuery(seoUrl: MaybeRef<string>, body?: OperationOptions<typeof readCustomProductDetailOperation, 'params'>): UseQueryReturnType<{
+    apiAlias: "product_detail";
+    configurator: components["schemas"]["PropertyGroup"][];
+    cross_sellings: components["schemas"]["CrossSellingElementCollection"];
+    custom_fields: GenericRecord;
+    product: components["schemas"]["Product"] & {
+        extensions?: {
+            novuSeoUrls?: GenericRecord;
+            search?: GenericRecord;
+            variants?: components["schemas"]["Product"][];
+        };
+    };
+}, Error>;
+export {};

package/dist/query/shipping/index.d.ts

@@ -0,0 +1 @@
+export * from './useReadShippingMethodQuery';

package/dist/query/shipping/useReadShippingMethodQuery.d.ts

@@ -0,0 +1,55 @@
+import { OperationOptions } from '../types/query';
+import { UndefinedInitialQueryOptions, UseQueryReturnType } from '@tanstack/vue-query';
+import { GenericRecord, components } from '../../../api-types/storeApiTypes';
+export declare const readShippingMethodOperation = "readShippingMethod post /shipping-method";
+export declare function useReadShippingMethodQueryOptions(options?: OperationOptions<typeof readShippingMethodOperation>): UndefinedInitialQueryOptions<{
+    aggregations?: GenericRecord;
+    elements: components["schemas"]["ShippingMethod"][];
+    total?: number;
+} & {
+    aggregations?: GenericRecord[];
+    entity?: string;
+    limit?: number;
+    page?: number;
+    total?: number;
+}, Error, {
+    aggregations?: GenericRecord;
+    elements: components["schemas"]["ShippingMethod"][];
+    total?: number;
+} & {
+    aggregations?: GenericRecord[];
+    entity?: string;
+    limit?: number;
+    page?: number;
+    total?: number;
+}, readonly ["shippingMethod", "list", {
+    readonly body: unknown;
+}]> & {
+    queryKey: readonly ["shippingMethod", "list", {
+        readonly body: unknown;
+    }] & {
+        [dataTagSymbol]: {
+            aggregations?: GenericRecord;
+            elements: components["schemas"]["ShippingMethod"][];
+            total?: number;
+        } & {
+            aggregations?: GenericRecord[];
+            entity?: string;
+            limit?: number;
+            page?: number;
+            total?: number;
+        };
+        [dataTagErrorSymbol]: Error;
+    };
+};
+export declare function useReadShippingMethodQuery(options?: OperationOptions<typeof readShippingMethodOperation>): UseQueryReturnType<{
+    aggregations?: GenericRecord;
+    elements: components["schemas"]["ShippingMethod"][];
+    total?: number;
+} & {
+    aggregations?: GenericRecord[];
+    entity?: string;
+    limit?: number;
+    page?: number;
+    total?: number;
+}, Error>;

package/dist/query/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './operations';
+export * from './query';

package/dist/query/types/operations.d.ts

@@ -0,0 +1,5 @@
+import { operations, Schemas as OriginalSchemas } from '../../../api-types/storeApiTypes.d.ts';
+export interface Operations extends operations {
+}
+export interface Schemas extends OriginalSchemas {
+}

package/dist/query/types/query.d.ts

@@ -0,0 +1,17 @@
+import { operations } from '../../../api-types/storeApiTypes.d.ts';
+import { QueryKey, UseQueryOptions } from '@tanstack/vue-query';
+import { OperationProp, OperationOptions as RawOperationOptions } from '@teamnovu/kit-shopware-api-client';
+import { MaybeRef, UnwrapRef } from 'vue';
+import { Operations } from './operations';
+export type PartialProps<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export type ShallowMaybeRefs<T> = {
+    [K in keyof T]: MaybeRef<T[K]>;
+};
+export type ShallowUnwrapRefs<T> = {
+    [K in keyof T]: UnwrapRef<T[K]>;
+};
+export type OperationKey = keyof operations;
+export type OperationBody<K extends OperationKey> = OperationProp<Operations, K, 'body'>;
+export type OperationResponse<K extends OperationKey> = OperationProp<Operations, K, 'response'>;
+export type OperationOptions<K extends OperationKey, OmitKeys extends keyof RawOperationOptions<Operations, K> = never> = MaybeRef<ShallowMaybeRefs<PartialProps<RawOperationOptions<Operations, K>, OmitKeys>>>;
+export type Options<K extends OperationKey, QK extends QueryKey = QueryKey> = UseQueryOptions<OperationResponse<K>, Error, OperationResponse<K>, OperationResponse<K>, QK>;

package/dist/util/index.d.ts

@@ -0,0 +1,3 @@
+export * from './unrefOptions';
+export * from './url';
+export * from './useOptimistic';

package/dist/util/unrefOptions.d.ts

@@ -0,0 +1,4 @@
+import { OperationOptions as RawOperationOptions } from '@teamnovu/kit-shopware-api-client';
+import { OperationOptions, PartialProps } from '../query/types/query';
+import { Operations } from '../query/types';
+export declare function unrefOptions<K extends keyof Operations, OmitKeys extends keyof RawOperationOptions<Operations, K> = never>(options: OperationOptions<K, OmitKeys> | undefined): PartialProps<RawOperationOptions<Operations, K>, OmitKeys>;

package/dist/util/useOptimistic.d.ts

@@ -0,0 +1,12 @@
+import { QueryKey, UseMutationOptions } from '@tanstack/vue-query';
+export declare function useOptimistic<CacheValue, UpdateValue>(queryKey: QueryKey, updateFn: (newValue: UpdateValue, oldValue: CacheValue) => CacheValue, options?: UseMutationOptions<unknown, unknown, UpdateValue, unknown>): {
+    onMutate: (newValue: UpdateValue) => Promise<{
+        previousValue: CacheValue | undefined;
+    }>;
+    onError: (err: unknown, newValue: UpdateValue, context: {
+        previousValue?: CacheValue;
+    } | undefined) => void;
+    onSettled: (data: unknown, error: unknown, variables: UpdateValue, context: {
+        previousValue?: CacheValue;
+    } | undefined) => void;
+};