@vendure/admin-ui 1.7.4 → 1.8.0

package/package/esm2015/core/components/breadcrumb/breadcrumb.component.js

@@ -0,0 +1,126 @@
+import { Component } from '@angular/core';
+import { ActivatedRoute, NavigationEnd, PRIMARY_OUTLET, Router } from '@angular/router';
+import { flatten } from 'lodash';
+import { combineLatest as observableCombineLatest, Observable, of as observableOf, Subject } from 'rxjs';
+import { filter, map, startWith, switchMap, takeUntil } from 'rxjs/operators';
+import { DataService } from '../../data/providers/data.service';
+/**
+ * A breadcrumbs component which reads the route config and any route that has a `data.breadcrumb` property will
+ * be displayed in the breadcrumb trail.
+ *
+ * The `breadcrumb` property can be a string or a function. If a function, it will be passed the route's `data`
+ * object (which will include all resolved keys) and any route params, and should return a BreadcrumbValue.
+ *
+ * See the test config to get an idea of allowable configs for breadcrumbs.
+ */
+export class BreadcrumbComponent {
+    constructor(router, route, dataService) {
+        this.router = router;
+        this.route = route;
+        this.dataService = dataService;
+        this.destroy$ = new Subject();
+        this.breadcrumbs$ = this.router.events.pipe(filter(event => event instanceof NavigationEnd), takeUntil(this.destroy$), startWith(true), switchMap(() => this.generateBreadcrumbs(this.route.root)));
+    }
+    ngOnDestroy() {
+        this.destroy$.next();
+        this.destroy$.complete();
+    }
+    generateBreadcrumbs(rootRoute) {
+        const breadcrumbParts = this.assembleBreadcrumbParts(rootRoute);
+        const breadcrumbObservables$ = breadcrumbParts.map(({ value$, path }) => {
+            return value$.pipe(map(value => {
+                if (isBreadcrumbLabelLinkPair(value)) {
+                    return {
+                        label: value.label,
+                        link: this.normalizeRelativeLinks(value.link, path),
+                    };
+                }
+                else if (isBreadcrumbPairArray(value)) {
+                    return value.map(val => ({
+                        label: val.label,
+                        link: this.normalizeRelativeLinks(val.link, path),
+                    }));
+                }
+                else {
+                    return {
+                        label: value,
+                        link: '/' + path.join('/'),
+                    };
+                }
+            }));
+        });
+        return observableCombineLatest(breadcrumbObservables$).pipe(map(links => flatten(links)));
+    }
+    /**
+     * Walks the route definition tree to assemble an array from which the breadcrumbs can be derived.
+     */
+    assembleBreadcrumbParts(rootRoute) {
+        const breadcrumbParts = [];
+        const inferredUrl = '';
+        const segmentPaths = [];
+        let currentRoute = rootRoute;
+        do {
+            const childRoutes = currentRoute.children;
+            currentRoute = null;
+            childRoutes.forEach((route) => {
+                if (route.outlet === PRIMARY_OUTLET) {
+                    const routeSnapshot = route.snapshot;
+                    let breadcrumbDef = route.routeConfig && route.routeConfig.data && route.routeConfig.data['breadcrumb'];
+                    segmentPaths.push(routeSnapshot.url.map(segment => segment.path).join('/'));
+                    if (breadcrumbDef) {
+                        if (isBreadcrumbFunction(breadcrumbDef)) {
+                            breadcrumbDef = breadcrumbDef(routeSnapshot.data, routeSnapshot.params, this.dataService);
+                        }
+                        const observableValue = isObservable(breadcrumbDef)
+                            ? breadcrumbDef
+                            : observableOf(breadcrumbDef);
+                        breadcrumbParts.push({ value$: observableValue, path: segmentPaths.slice() });
+                    }
+                    currentRoute = route;
+                }
+            });
+        } while (currentRoute);
+        return breadcrumbParts;
+    }
+    /**
+     * Accounts for relative routes in the link array, i.e. arrays whose first element is either:
+     * * `./`   - this appends the rest of the link segments to the current active route
+     * * `../`  - this removes the last segment of the current active route, and appends the link segments
+     *            to the parent route.
+     */
+    normalizeRelativeLinks(link, segmentPaths) {
+        const clone = link.slice();
+        if (clone[0] === './') {
+            clone[0] = segmentPaths.join('/');
+        }
+        if (clone[0] === '../') {
+            clone[0] = segmentPaths.slice(0, -1).join('/');
+        }
+        return clone.filter(segment => segment !== '');
+    }
+}
+BreadcrumbComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'vdr-breadcrumb',
+                template: "<nav role=\"navigation\">\r\n    <ul class=\"breadcrumbs\">\r\n        <li *ngFor=\"let breadcrumb of (breadcrumbs$ | async); let isLast = last\">\r\n            <a [routerLink]=\"breadcrumb.link\" *ngIf=\"!isLast\">{{ breadcrumb.label | translate }}</a>\r\n            <ng-container *ngIf=\"isLast\">{{ breadcrumb.label | translate }}</ng-container>\r\n        </li>\r\n    </ul>\r\n</nav>\r\n",
+                styles: ["@charset \"UTF-8\";:host{display:block}@media screen and (min-width: 768px){:host{padding:0 1rem}}.breadcrumbs{list-style-type:none;display:flex;overflow-x:auto;max-width:100vw;padding:0 3px}@media screen and (min-width: 768px){.breadcrumbs{padding:0}}.breadcrumbs li{font-size:16px;display:inline-block;margin-right:10px;white-space:nowrap}.breadcrumbs li:not(:last-child):after{content:\"\\203a\";top:0;color:var(--color-grey-400);margin-left:10px}\n"]
+            },] }
+];
+BreadcrumbComponent.ctorParameters = () => [
+    { type: Router },
+    { type: ActivatedRoute },
+    { type: DataService }
+];
+function isBreadcrumbFunction(value) {
+    return typeof value === 'function';
+}
+function isObservable(value) {
+    return value instanceof Observable;
+}
+function isBreadcrumbLabelLinkPair(value) {
+    return value.hasOwnProperty('label') && value.hasOwnProperty('link');
+}
+function isBreadcrumbPairArray(value) {
+    return Array.isArray(value) && isBreadcrumbLabelLinkPair(value[0]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"breadcrumb.component.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/components/breadcrumb/breadcrumb.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component, OnDestroy } from '@angular/core';\r\nimport { ActivatedRoute, Data, NavigationEnd, Params, PRIMARY_OUTLET, Router } from '@angular/router';\r\nimport { flatten } from 'lodash';\r\nimport { combineLatest as observableCombineLatest, Observable, of as observableOf, Subject } from 'rxjs';\r\nimport { filter, map, startWith, switchMap, takeUntil } from 'rxjs/operators';\r\n\r\nimport { DataService } from '../../data/providers/data.service';\r\n\r\nexport type BreadcrumbString = string;\r\nexport interface BreadcrumbLabelLinkPair {\r\n    label: string;\r\n    link: any[];\r\n}\r\nexport type BreadcrumbValue = BreadcrumbString | BreadcrumbLabelLinkPair | BreadcrumbLabelLinkPair[];\r\nexport type BreadcrumbFunction = (\r\n    data: Data,\r\n    params: Params,\r\n    dataService: DataService,\r\n) => BreadcrumbValue | Observable<BreadcrumbValue>;\r\nexport type BreadcrumbDefinition = BreadcrumbValue | BreadcrumbFunction | Observable<BreadcrumbValue>;\r\n\r\n/**\r\n * A breadcrumbs component which reads the route config and any route that has a `data.breadcrumb` property will\r\n * be displayed in the breadcrumb trail.\r\n *\r\n * The `breadcrumb` property can be a string or a function. If a function, it will be passed the route's `data`\r\n * object (which will include all resolved keys) and any route params, and should return a BreadcrumbValue.\r\n *\r\n * See the test config to get an idea of allowable configs for breadcrumbs.\r\n */\r\n@Component({\r\n    selector: 'vdr-breadcrumb',\r\n    templateUrl: './breadcrumb.component.html',\r\n    styleUrls: ['./breadcrumb.component.scss'],\r\n})\r\nexport class BreadcrumbComponent implements OnDestroy {\r\n    breadcrumbs$: Observable<Array<{ link: string | any[]; label: string }>>;\r\n    private destroy$ = new Subject<void>();\r\n\r\n    constructor(private router: Router, private route: ActivatedRoute, private dataService: DataService) {\r\n        this.breadcrumbs$ = this.router.events.pipe(\r\n            filter(event => event instanceof NavigationEnd),\r\n            takeUntil(this.destroy$),\r\n            startWith(true),\r\n            switchMap(() => this.generateBreadcrumbs(this.route.root)),\r\n        );\r\n    }\r\n\r\n    ngOnDestroy(): void {\r\n        this.destroy$.next();\r\n        this.destroy$.complete();\r\n    }\r\n\r\n    private generateBreadcrumbs(\r\n        rootRoute: ActivatedRoute,\r\n    ): Observable<Array<{ link: Array<string | any>; label: string }>> {\r\n        const breadcrumbParts = this.assembleBreadcrumbParts(rootRoute);\r\n        const breadcrumbObservables$ = breadcrumbParts.map(({ value$, path }) => {\r\n            return value$.pipe(\r\n                map(value => {\r\n                    if (isBreadcrumbLabelLinkPair(value)) {\r\n                        return {\r\n                            label: value.label,\r\n                            link: this.normalizeRelativeLinks(value.link, path),\r\n                        };\r\n                    } else if (isBreadcrumbPairArray(value)) {\r\n                        return value.map(val => ({\r\n                            label: val.label,\r\n                            link: this.normalizeRelativeLinks(val.link, path),\r\n                        }));\r\n                    } else {\r\n                        return {\r\n                            label: value,\r\n                            link: '/' + path.join('/'),\r\n                        };\r\n                    }\r\n                }),\r\n            ) as Observable<BreadcrumbLabelLinkPair | BreadcrumbLabelLinkPair[]>;\r\n        });\r\n\r\n        return observableCombineLatest(breadcrumbObservables$).pipe(map(links => flatten(links)));\r\n    }\r\n\r\n    /**\r\n     * Walks the route definition tree to assemble an array from which the breadcrumbs can be derived.\r\n     */\r\n    private assembleBreadcrumbParts(\r\n        rootRoute: ActivatedRoute,\r\n    ): Array<{ value$: Observable<BreadcrumbValue>; path: string[] }> {\r\n        const breadcrumbParts: Array<{ value$: Observable<BreadcrumbValue>; path: string[] }> = [];\r\n        const inferredUrl = '';\r\n        const segmentPaths: string[] = [];\r\n        let currentRoute: ActivatedRoute | null = rootRoute;\r\n        do {\r\n            const childRoutes = currentRoute.children;\r\n            currentRoute = null;\r\n            childRoutes.forEach((route: ActivatedRoute) => {\r\n                if (route.outlet === PRIMARY_OUTLET) {\r\n                    const routeSnapshot = route.snapshot;\r\n                    let breadcrumbDef: BreadcrumbDefinition | undefined =\r\n                        route.routeConfig && route.routeConfig.data && route.routeConfig.data['breadcrumb'];\r\n                    segmentPaths.push(routeSnapshot.url.map(segment => segment.path).join('/'));\r\n\r\n                    if (breadcrumbDef) {\r\n                        if (isBreadcrumbFunction(breadcrumbDef)) {\r\n                            breadcrumbDef = breadcrumbDef(\r\n                                routeSnapshot.data,\r\n                                routeSnapshot.params,\r\n                                this.dataService,\r\n                            );\r\n                        }\r\n                        const observableValue = isObservable(breadcrumbDef)\r\n                            ? breadcrumbDef\r\n                            : observableOf(breadcrumbDef);\r\n                        breadcrumbParts.push({ value$: observableValue, path: segmentPaths.slice() });\r\n                    }\r\n                    currentRoute = route;\r\n                }\r\n            });\r\n        } while (currentRoute);\r\n\r\n        return breadcrumbParts;\r\n    }\r\n\r\n    /**\r\n     * Accounts for relative routes in the link array, i.e. arrays whose first element is either:\r\n     * * `./`   - this appends the rest of the link segments to the current active route\r\n     * * `../`  - this removes the last segment of the current active route, and appends the link segments\r\n     *            to the parent route.\r\n     */\r\n    private normalizeRelativeLinks(link: any[], segmentPaths: string[]): any[] {\r\n        const clone = link.slice();\r\n        if (clone[0] === './') {\r\n            clone[0] = segmentPaths.join('/');\r\n        }\r\n        if (clone[0] === '../') {\r\n            clone[0] = segmentPaths.slice(0, -1).join('/');\r\n        }\r\n        return clone.filter(segment => segment !== '');\r\n    }\r\n}\r\n\r\nfunction isBreadcrumbFunction(value: BreadcrumbDefinition): value is BreadcrumbFunction {\r\n    return typeof value === 'function';\r\n}\r\n\r\nfunction isObservable(value: BreadcrumbDefinition): value is Observable<BreadcrumbValue> {\r\n    return value instanceof Observable;\r\n}\r\n\r\nfunction isBreadcrumbLabelLinkPair(value: BreadcrumbValue): value is BreadcrumbLabelLinkPair {\r\n    return value.hasOwnProperty('label') && value.hasOwnProperty('link');\r\n}\r\n\r\nfunction isBreadcrumbPairArray(value: BreadcrumbValue): value is BreadcrumbLabelLinkPair[] {\r\n    return Array.isArray(value) && isBreadcrumbLabelLinkPair(value[0]);\r\n}\r\n"]}

package/package/esm2015/core/data/definitions/collection-definitions.js

@@ -0,0 +1,173 @@
+import { gql } from 'apollo-angular';
+import { ASSET_FRAGMENT } from './product-definitions';
+import { CONFIGURABLE_OPERATION_DEF_FRAGMENT, CONFIGURABLE_OPERATION_FRAGMENT } from './shared-definitions';
+export const GET_COLLECTION_FILTERS = gql `
+    query GetCollectionFilters {
+        collectionFilters {
+            ...ConfigurableOperationDef
+        }
+    }
+    ${CONFIGURABLE_OPERATION_DEF_FRAGMENT}
+`;
+export const COLLECTION_FRAGMENT = gql `
+    fragment Collection on Collection {
+        id
+        createdAt
+        updatedAt
+        name
+        slug
+        description
+        isPrivate
+        languageCode
+        breadcrumbs {
+            id
+            name
+            slug
+        }
+        featuredAsset {
+            ...Asset
+        }
+        assets {
+            ...Asset
+        }
+        filters {
+            ...ConfigurableOperation
+        }
+        translations {
+            id
+            languageCode
+            name
+            slug
+            description
+        }
+        parent {
+            id
+            name
+        }
+        children {
+            id
+            name
+        }
+    }
+    ${ASSET_FRAGMENT}
+    ${CONFIGURABLE_OPERATION_FRAGMENT}
+`;
+export const GET_COLLECTION_LIST = gql `
+    query GetCollectionList($options: CollectionListOptions) {
+        collections(options: $options) {
+            items {
+                id
+                name
+                slug
+                description
+                isPrivate
+                featuredAsset {
+                    ...Asset
+                }
+                parent {
+                    id
+                }
+            }
+            totalItems
+        }
+    }
+    ${ASSET_FRAGMENT}
+`;
+export const GET_COLLECTION = gql `
+    query GetCollection($id: ID!) {
+        collection(id: $id) {
+            ...Collection
+        }
+    }
+    ${COLLECTION_FRAGMENT}
+`;
+export const CREATE_COLLECTION = gql `
+    mutation CreateCollection($input: CreateCollectionInput!) {
+        createCollection(input: $input) {
+            ...Collection
+        }
+    }
+    ${COLLECTION_FRAGMENT}
+`;
+export const UPDATE_COLLECTION = gql `
+    mutation UpdateCollection($input: UpdateCollectionInput!) {
+        updateCollection(input: $input) {
+            ...Collection
+        }
+    }
+    ${COLLECTION_FRAGMENT}
+`;
+export const MOVE_COLLECTION = gql `
+    mutation MoveCollection($input: MoveCollectionInput!) {
+        moveCollection(input: $input) {
+            ...Collection
+        }
+    }
+    ${COLLECTION_FRAGMENT}
+`;
+export const DELETE_COLLECTION = gql `
+    mutation DeleteCollection($id: ID!) {
+        deleteCollection(id: $id) {
+            result
+            message
+        }
+    }
+`;
+export const DELETE_COLLECTIONS = gql `
+    mutation DeleteCollections($ids: [ID!]!) {
+        deleteCollections(ids: $ids) {
+            result
+            message
+        }
+    }
+`;
+export const GET_COLLECTION_CONTENTS = gql `
+    query GetCollectionContents($id: ID!, $options: ProductVariantListOptions) {
+        collection(id: $id) {
+            id
+            name
+            productVariants(options: $options) {
+                items {
+                    id
+                    productId
+                    name
+                    sku
+                }
+                totalItems
+            }
+        }
+    }
+`;
+export const PREVIEW_COLLECTION_CONTENTS = gql `
+    query PreviewCollectionContents(
+        $input: PreviewCollectionVariantsInput!
+        $options: ProductVariantListOptions
+    ) {
+        previewCollectionVariants(input: $input, options: $options) {
+            items {
+                id
+                productId
+                name
+                sku
+            }
+            totalItems
+        }
+    }
+`;
+export const ASSIGN_COLLECTIONS_TO_CHANNEL = gql `
+    mutation AssignCollectionsToChannel($input: AssignCollectionsToChannelInput!) {
+        assignCollectionsToChannel(input: $input) {
+            id
+            name
+        }
+    }
+`;
+export const REMOVE_COLLECTIONS_FROM_CHANNEL = gql `
+    mutation RemoveCollectionsFromChannel($input: RemoveCollectionsFromChannelInput!) {
+        removeCollectionsFromChannel(input: $input) {
+            id
+            name
+        }
+    }
+`;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"collection-definitions.js","sourceRoot":"","sources":["../../../../../src/lib/core/src/data/definitions/collection-definitions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,MAAM,gBAAgB,CAAC;AAErC,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,mCAAmC,EAAE,+BAA+B,EAAE,MAAM,sBAAsB,CAAC;AAE5G,MAAM,CAAC,MAAM,sBAAsB,GAAG,GAAG,CAAA;;;;;;MAMnC,mCAAmC;CACxC,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAwChC,cAAc;MACd,+BAA+B;CACpC,CAAC;AAEF,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;;;;MAmBhC,cAAc;CACnB,CAAC;AAEF,MAAM,CAAC,MAAM,cAAc,GAAG,GAAG,CAAA;;;;;;MAM3B,mBAAmB;CACxB,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAG,GAAG,CAAA;;;;;;MAM9B,mBAAmB;CACxB,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAG,GAAG,CAAA;;;;;;MAM9B,mBAAmB;CACxB,CAAC;AAEF,MAAM,CAAC,MAAM,eAAe,GAAG,GAAG,CAAA;;;;;;MAM5B,mBAAmB;CACxB,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAG,GAAG,CAAA;;;;;;;CAOnC,CAAC;AAEF,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,CAAA;;;;;;;CAOpC,CAAC;AAEF,MAAM,CAAC,MAAM,uBAAuB,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;;CAgBzC,CAAC;AAEF,MAAM,CAAC,MAAM,2BAA2B,GAAG,GAAG,CAAA;;;;;;;;;;;;;;;CAe7C,CAAC;AAEF,MAAM,CAAC,MAAM,6BAA6B,GAAG,GAAG,CAAA;;;;;;;CAO/C,CAAC;AAEF,MAAM,CAAC,MAAM,+BAA+B,GAAG,GAAG,CAAA;;;;;;;CAOjD,CAAC","sourcesContent":["import { gql } from 'apollo-angular';\r\n\r\nimport { ASSET_FRAGMENT } from './product-definitions';\r\nimport { CONFIGURABLE_OPERATION_DEF_FRAGMENT, CONFIGURABLE_OPERATION_FRAGMENT } from './shared-definitions';\r\n\r\nexport const GET_COLLECTION_FILTERS = gql`\r\n    query GetCollectionFilters {\r\n        collectionFilters {\r\n            ...ConfigurableOperationDef\r\n        }\r\n    }\r\n    ${CONFIGURABLE_OPERATION_DEF_FRAGMENT}\r\n`;\r\n\r\nexport const COLLECTION_FRAGMENT = gql`\r\n    fragment Collection on Collection {\r\n        id\r\n        createdAt\r\n        updatedAt\r\n        name\r\n        slug\r\n        description\r\n        isPrivate\r\n        languageCode\r\n        breadcrumbs {\r\n            id\r\n            name\r\n            slug\r\n        }\r\n        featuredAsset {\r\n            ...Asset\r\n        }\r\n        assets {\r\n            ...Asset\r\n        }\r\n        filters {\r\n            ...ConfigurableOperation\r\n        }\r\n        translations {\r\n            id\r\n            languageCode\r\n            name\r\n            slug\r\n            description\r\n        }\r\n        parent {\r\n            id\r\n            name\r\n        }\r\n        children {\r\n            id\r\n            name\r\n        }\r\n    }\r\n    ${ASSET_FRAGMENT}\r\n    ${CONFIGURABLE_OPERATION_FRAGMENT}\r\n`;\r\n\r\nexport const GET_COLLECTION_LIST = gql`\r\n    query GetCollectionList($options: CollectionListOptions) {\r\n        collections(options: $options) {\r\n            items {\r\n                id\r\n                name\r\n                slug\r\n                description\r\n                isPrivate\r\n                featuredAsset {\r\n                    ...Asset\r\n                }\r\n                parent {\r\n                    id\r\n                }\r\n            }\r\n            totalItems\r\n        }\r\n    }\r\n    ${ASSET_FRAGMENT}\r\n`;\r\n\r\nexport const GET_COLLECTION = gql`\r\n    query GetCollection($id: ID!) {\r\n        collection(id: $id) {\r\n            ...Collection\r\n        }\r\n    }\r\n    ${COLLECTION_FRAGMENT}\r\n`;\r\n\r\nexport const CREATE_COLLECTION = gql`\r\n    mutation CreateCollection($input: CreateCollectionInput!) {\r\n        createCollection(input: $input) {\r\n            ...Collection\r\n        }\r\n    }\r\n    ${COLLECTION_FRAGMENT}\r\n`;\r\n\r\nexport const UPDATE_COLLECTION = gql`\r\n    mutation UpdateCollection($input: UpdateCollectionInput!) {\r\n        updateCollection(input: $input) {\r\n            ...Collection\r\n        }\r\n    }\r\n    ${COLLECTION_FRAGMENT}\r\n`;\r\n\r\nexport const MOVE_COLLECTION = gql`\r\n    mutation MoveCollection($input: MoveCollectionInput!) {\r\n        moveCollection(input: $input) {\r\n            ...Collection\r\n        }\r\n    }\r\n    ${COLLECTION_FRAGMENT}\r\n`;\r\n\r\nexport const DELETE_COLLECTION = gql`\r\n    mutation DeleteCollection($id: ID!) {\r\n        deleteCollection(id: $id) {\r\n            result\r\n            message\r\n        }\r\n    }\r\n`;\r\n\r\nexport const DELETE_COLLECTIONS = gql`\r\n    mutation DeleteCollections($ids: [ID!]!) {\r\n        deleteCollections(ids: $ids) {\r\n            result\r\n            message\r\n        }\r\n    }\r\n`;\r\n\r\nexport const GET_COLLECTION_CONTENTS = gql`\r\n    query GetCollectionContents($id: ID!, $options: ProductVariantListOptions) {\r\n        collection(id: $id) {\r\n            id\r\n            name\r\n            productVariants(options: $options) {\r\n                items {\r\n                    id\r\n                    productId\r\n                    name\r\n                    sku\r\n                }\r\n                totalItems\r\n            }\r\n        }\r\n    }\r\n`;\r\n\r\nexport const PREVIEW_COLLECTION_CONTENTS = gql`\r\n    query PreviewCollectionContents(\r\n        $input: PreviewCollectionVariantsInput!\r\n        $options: ProductVariantListOptions\r\n    ) {\r\n        previewCollectionVariants(input: $input, options: $options) {\r\n            items {\r\n                id\r\n                productId\r\n                name\r\n                sku\r\n            }\r\n            totalItems\r\n        }\r\n    }\r\n`;\r\n\r\nexport const ASSIGN_COLLECTIONS_TO_CHANNEL = gql`\r\n    mutation AssignCollectionsToChannel($input: AssignCollectionsToChannelInput!) {\r\n        assignCollectionsToChannel(input: $input) {\r\n            id\r\n            name\r\n        }\r\n    }\r\n`;\r\n\r\nexport const REMOVE_COLLECTIONS_FROM_CHANNEL = gql`\r\n    mutation RemoveCollectionsFromChannel($input: RemoveCollectionsFromChannelInput!) {\r\n        removeCollectionsFromChannel(input: $input) {\r\n            id\r\n            name\r\n        }\r\n    }\r\n`;\r\n"]}

package/package/esm2015/core/data/definitions/facet-definitions.js

@@ -0,0 +1,140 @@
+import { gql } from 'apollo-angular';
+export const FACET_VALUE_FRAGMENT = gql `
+    fragment FacetValue on FacetValue {
+        id
+        createdAt
+        updatedAt
+        languageCode
+        code
+        name
+        translations {
+            id
+            languageCode
+            name
+        }
+        facet {
+            id
+            createdAt
+            updatedAt
+            name
+        }
+    }
+`;
+export const FACET_WITH_VALUES_FRAGMENT = gql `
+    fragment FacetWithValues on Facet {
+        id
+        createdAt
+        updatedAt
+        languageCode
+        isPrivate
+        code
+        name
+        translations {
+            id
+            languageCode
+            name
+        }
+        values {
+            ...FacetValue
+        }
+    }
+    ${FACET_VALUE_FRAGMENT}
+`;
+export const CREATE_FACET = gql `
+    mutation CreateFacet($input: CreateFacetInput!) {
+        createFacet(input: $input) {
+            ...FacetWithValues
+        }
+    }
+    ${FACET_WITH_VALUES_FRAGMENT}
+`;
+export const UPDATE_FACET = gql `
+    mutation UpdateFacet($input: UpdateFacetInput!) {
+        updateFacet(input: $input) {
+            ...FacetWithValues
+        }
+    }
+    ${FACET_WITH_VALUES_FRAGMENT}
+`;
+export const DELETE_FACET = gql `
+    mutation DeleteFacet($id: ID!, $force: Boolean) {
+        deleteFacet(id: $id, force: $force) {
+            result
+            message
+        }
+    }
+`;
+export const DELETE_FACETS = gql `
+    mutation DeleteFacets($ids: [ID!]!, $force: Boolean) {
+        deleteFacets(ids: $ids, force: $force) {
+            result
+            message
+        }
+    }
+`;
+export const CREATE_FACET_VALUES = gql `
+    mutation CreateFacetValues($input: [CreateFacetValueInput!]!) {
+        createFacetValues(input: $input) {
+            ...FacetValue
+        }
+    }
+    ${FACET_VALUE_FRAGMENT}
+`;
+export const UPDATE_FACET_VALUES = gql `
+    mutation UpdateFacetValues($input: [UpdateFacetValueInput!]!) {
+        updateFacetValues(input: $input) {
+            ...FacetValue
+        }
+    }
+    ${FACET_VALUE_FRAGMENT}
+`;
+export const DELETE_FACET_VALUES = gql `
+    mutation DeleteFacetValues($ids: [ID!]!, $force: Boolean) {
+        deleteFacetValues(ids: $ids, force: $force) {
+            result
+            message
+        }
+    }
+`;
+export const GET_FACET_LIST = gql `
+    query GetFacetList($options: FacetListOptions) {
+        facets(options: $options) {
+            items {
+                ...FacetWithValues
+            }
+            totalItems
+        }
+    }
+    ${FACET_WITH_VALUES_FRAGMENT}
+`;
+export const GET_FACET_WITH_VALUES = gql `
+    query GetFacetWithValues($id: ID!) {
+        facet(id: $id) {
+            ...FacetWithValues
+        }
+    }
+    ${FACET_WITH_VALUES_FRAGMENT}
+`;
+export const ASSIGN_FACETS_TO_CHANNEL = gql `
+    mutation AssignFacetsToChannel($input: AssignFacetsToChannelInput!) {
+        assignFacetsToChannel(input: $input) {
+            id
+        }
+    }
+`;
+export const REMOVE_FACETS_FROM_CHANNEL = gql `
+    mutation RemoveFacetsFromChannel($input: RemoveFacetsFromChannelInput!) {
+        removeFacetsFromChannel(input: $input) {
+            ... on Facet {
+                id
+            }
+            ... on FacetInUseError {
+                errorCode
+                message
+                variantCount
+                productCount
+            }
+        }
+    }
+`;
+//# sourceMappingURL=data:application/json;base64,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