@sanity/hierarchical-document-list 0.1.0 → 1.1.0

package/lib/createDeskHierarchy.js

@@ -1,67 +1,84 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-import { jsx as _jsx } from "react/jsx-runtime";
-import S from '@sanity/desk-tool/structure-builder';
-import { AddIcon } from '@sanity/icons';
-import TreeDeskStructure from './TreeDeskStructure';
-var deskTreeValidator = function (props) {
-    var documentId = props.documentId, referenceTo = props.referenceTo;
-    if (typeof documentId !== 'string' && !documentId) {
-        throw new Error('[hierarchical input] Please add a documentId to your tree');
-    }
-    if (!Array.isArray(referenceTo)) {
-        throw new Error("[hierarchical input] Missing valid 'referenceTo' in createDeskHierarchy (documentId \"".concat(documentId, "\")"));
-    }
-    return function (deskProps) { return _jsx(TreeDeskStructure, __assign({}, deskProps, { options: props }), void 0); };
-};
-export default function createDeskHierarchy(props) {
-    var documentId = props.documentId, referenceTo = props.referenceTo, referenceOptions = props.referenceOptions;
-    var mainList = ((referenceTo === null || referenceTo === void 0 ? void 0 : referenceTo.length) === 1
-        ? S.documentTypeList(referenceTo[0]).schemaType(referenceTo[0])
-        : S.documentList().filter('_type in $types').params({ types: referenceTo }))
-        .id(documentId)
-        .menuItems((referenceTo || []).map(function (schemaType) {
-        return S.menuItem()
-            .intent({
-            type: 'create',
-            params: { type: schemaType, template: schemaType }
-        })
-            // @TODO: get the title for each schema type
-            .title(schemaType)
-            .icon(AddIcon);
-    }))
-        .canHandleIntent(function (intent, context) {
-        if (intent === 'edit' && context.id === props.documentId) {
-            return true;
-        }
-        if (intent === 'create' && referenceTo.includes(context.type)) {
-            return true;
-        }
-        return false;
-    });
-    if (referenceOptions === null || referenceOptions === void 0 ? void 0 : referenceOptions.filter) {
-        mainList = mainList.filter(referenceOptions.filter);
-    }
-    if (referenceOptions === null || referenceOptions === void 0 ? void 0 : referenceOptions.filterParams) {
-        mainList = mainList.params(referenceOptions.filterParams);
-    }
-    return S.listItem()
-        .id(documentId)
-        .title(props.title || documentId)
-        .icon(props.icon)
-        .child(Object.assign(mainList.serialize(), {
-        type: 'component',
-        component: deskTreeValidator(props),
-        options: props,
-        __preserveInstance: true
-    }, props.title ? { title: props.title } : {}));
-}
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var jsx_runtime_1 = require("react/jsx-runtime");
+var structure_builder_1 = __importDefault(require("@sanity/desk-tool/structure-builder"));
+var icons_1 = require("@sanity/icons");
+var schema_1 = __importDefault(require("part:@sanity/base/schema"));
+var TreeDeskStructure_1 = __importDefault(require("./TreeDeskStructure"));
+var throwError_1 = __importDefault(require("./utils/throwError"));
+var deskTreeValidator = function (props) {
+    var documentId = props.documentId, referenceTo = props.referenceTo;
+    if (typeof documentId !== 'string' && !documentId) {
+        (0, throwError_1.default)('invalidDocumentId');
+    }
+    if (!Array.isArray(referenceTo)) {
+        (0, throwError_1.default)('invalidReferenceTo', "(documentId \"".concat(documentId, "\")"));
+    }
+    return function (deskProps) { return (0, jsx_runtime_1.jsx)(TreeDeskStructure_1.default, __assign({}, deskProps, { options: props }), void 0); };
+};
+function createDeskHierarchy(props) {
+    var documentId = props.documentId, referenceTo = props.referenceTo, referenceOptions = props.referenceOptions;
+    /**
+     * Context: With multiple referenced document types we can’t set S.documentList().schemaType(),
+     * which only accepts one type. So the desk doesn’t have an expanded schemaType to access and
+     * try creating a new document without that, which breaks resolveEnabledActions (and probably more)
+     * in packages\@sanity\base\src\actions\utils\legacy_documentActionUtils.js
+     */
+    var safelyCreatableTypes = referenceTo.slice(0, 1);
+    var mainList = ((safelyCreatableTypes === null || safelyCreatableTypes === void 0 ? void 0 : safelyCreatableTypes.length) === 1
+        ? structure_builder_1.default.documentTypeList(safelyCreatableTypes[0]).schemaType(safelyCreatableTypes[0])
+        : structure_builder_1.default.documentList().filter('_type in $types').params({ types: safelyCreatableTypes }))
+        .id(documentId)
+        .menuItems((safelyCreatableTypes || []).map(function (schemaType) {
+        var _a, _b;
+        return structure_builder_1.default.menuItem()
+            .intent({
+            type: 'create',
+            params: { type: schemaType }
+        })
+            .title("Create ".concat((_a = schema_1.default.get(schemaType)) === null || _a === void 0 ? void 0 : _a.title))
+            .icon(((_b = schema_1.default.get(schemaType)) === null || _b === void 0 ? void 0 : _b.icon) || icons_1.AddIcon);
+    }))
+        .canHandleIntent(function (intent, context) {
+        // Can edit itself
+        if (intent === 'edit' && context.id === props.documentId) {
+            return true;
+        }
+        // Can create & edit referenced document types
+        if (safelyCreatableTypes.includes(context.type)) {
+            return true;
+        }
+        return false;
+    });
+    if (referenceOptions === null || referenceOptions === void 0 ? void 0 : referenceOptions.filter) {
+        mainList = mainList.filter(referenceOptions.filter);
+    }
+    if (referenceOptions === null || referenceOptions === void 0 ? void 0 : referenceOptions.filterParams) {
+        mainList = mainList.params(referenceOptions.filterParams);
+    }
+    return structure_builder_1.default.listItem()
+        .id(documentId)
+        .title(props.title || documentId)
+        .icon(props.icon)
+        .child(Object.assign(mainList.serialize(), {
+        type: 'component',
+        component: deskTreeValidator(props),
+        options: props,
+        __preserveInstance: true
+    }, props.title ? { title: props.title } : {}));
+}
+exports.default = createDeskHierarchy;

package/lib/createHierarchicalSchemas.d.ts

@@ -0,0 +1,98 @@
+import { ArraySchemaType } from '@sanity/types';
+import * as React from 'react';
+import { TreeDeskStructureProps, TreeFieldSchema } from './types';
+declare type SchemaOptions = Omit<TreeDeskStructureProps, 'documentId' | 'maxDepth'>;
+export declare function createHierarchicalField({ name, title, options, ...rest }: TreeFieldSchema): Omit<ArraySchemaType, 'type' | 'jsonType' | 'of'> & {
+    type: string;
+    inputComponent: React.FC<any>;
+    of?: any[];
+};
+export default function createHierarchicalSchemas(options: SchemaOptions): ({
+    name: string;
+    title: string;
+    type: string;
+    fields: ({
+        name: string;
+        type: string;
+    } | {
+        name: string;
+        type: string;
+        title: string;
+        fields: ({
+            name: string;
+            type: string;
+            weak?: undefined;
+            to?: undefined;
+            options?: undefined;
+        } | {
+            name: string;
+            type: string;
+            weak: boolean;
+            to: {
+                type: string;
+            }[];
+            options: {
+                filter?: string | undefined;
+                filterParams?: Record<string, unknown> | undefined;
+            } | undefined;
+        })[];
+    })[];
+} | {
+    name: string;
+    title: string;
+    type: string;
+    of: ({
+        name: string;
+        title: string;
+        type: string;
+        fields: ({
+            name: string;
+            type: string;
+        } | {
+            name: string;
+            type: string;
+            title: string;
+            fields: ({
+                name: string;
+                type: string;
+                weak?: undefined;
+                to?: undefined;
+                options?: undefined;
+            } | {
+                name: string;
+                type: string;
+                weak: boolean;
+                to: {
+                    type: string;
+                }[];
+                options: {
+                    filter?: string | undefined;
+                    filterParams?: Record<string, unknown> | undefined;
+                } | undefined;
+            })[];
+        })[];
+    } | {
+        type: string;
+    })[];
+} | {
+    name: string | undefined;
+    title: string;
+    type: string;
+    liveEdit: boolean;
+    fields: (Omit<ArraySchemaType<unknown>, "type" | "of" | "jsonType"> & {
+        type: string;
+        inputComponent: React.FC<any>;
+        of?: any[] | undefined;
+    })[];
+    preview: {
+        select: {
+            id: string;
+            tree: string;
+        };
+        prepare({ id, tree }: {
+            id: string;
+            tree: unknown[];
+        }): Record<string, string>;
+    };
+})[];
+export {};

package/lib/createHierarchicalSchemas.js

@@ -0,0 +1,138 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHierarchicalField = void 0;
+var TreeDeskStructure_1 = require("./TreeDeskStructure");
+var TreeInputComponent_1 = __importDefault(require("./TreeInputComponent"));
+var injectNodeTypeInPatches_1 = require("./utils/injectNodeTypeInPatches");
+var throwError_1 = __importDefault(require("./utils/throwError"));
+function createHierarchicalNodeValueType(_a) {
+    var referenceTo = _a.referenceTo, referenceOptions = _a.referenceOptions, documentType = _a.documentType;
+    return {
+        // when used inside the field, name & type are overwritten by createHierarchicalNodeType
+        name: documentType ? (0, injectNodeTypeInPatches_1.getSchemaTypeName)(documentType, 'nodeValue') : injectNodeTypeInPatches_1.INTERNAL_NODE_VALUE_TYPE,
+        type: 'object',
+        title: "Hierarchical node value (".concat(documentType, ")"),
+        fields: [
+            { name: 'docType', type: 'string' },
+            {
+                name: 'reference',
+                type: 'reference',
+                weak: true,
+                to: referenceTo.map(function (type) { return ({ type: type }); }),
+                options: referenceOptions
+            }
+        ]
+    };
+}
+function createHierarchicalNodeType(options) {
+    return {
+        // name & type are overwritten by createHierarchicalField
+        name: options.documentType
+            ? (0, injectNodeTypeInPatches_1.getSchemaTypeName)(options.documentType, 'node')
+            : injectNodeTypeInPatches_1.INTERNAL_NODE_TYPE,
+        title: "Hierarchical node (".concat(options.documentType, ")"),
+        type: 'object',
+        fields: [
+            { name: 'parent', type: 'string' },
+            options.documentType
+                ? { name: 'value', type: (0, injectNodeTypeInPatches_1.getSchemaTypeName)(options.documentType, 'nodeValue') }
+                : // If no documentType is defined, use an anonymized inline object to avoid
+                 __assign(__assign({}, createHierarchicalNodeValueType(options)), { name: 'value', type: 'object' })
+        ]
+    };
+}
+function createHierarchicalArrayType(options) {
+    return {
+        // name & type are overwritten by createHierarchicalField
+        name: options.documentType
+            ? (0, injectNodeTypeInPatches_1.getSchemaTypeName)(options.documentType, 'array')
+            : injectNodeTypeInPatches_1.INTERNAL_NODE_ARRAY_TYPE,
+        title: "Hierarchical array of nodes (".concat(options.documentType, ")"),
+        type: 'array',
+        of: [
+            options.documentType
+                ? { type: (0, injectNodeTypeInPatches_1.getSchemaTypeName)(options.documentType, 'node') }
+                : createHierarchicalNodeType(options)
+        ]
+    };
+}
+function createHierarchicalField(_a) {
+    var name = _a.name, title = _a.title, options = _a.options, rest = __rest(_a, ["name", "title", "options"]);
+    if (!Array.isArray(options === null || options === void 0 ? void 0 : options.referenceTo)) {
+        (0, throwError_1.default)('invalidReferenceTo', "(field of name \"".concat(name, "\")"));
+    }
+    return __assign(__assign(__assign({}, rest), { name: name, title: title, inputComponent: TreeInputComponent_1.default, options: options }), (options.documentType
+        ? { type: (0, injectNodeTypeInPatches_1.getSchemaTypeName)(options.documentType, 'array') }
+        : __assign(__assign({}, createHierarchicalArrayType(options)), { name: name })));
+}
+exports.createHierarchicalField = createHierarchicalField;
+function createHierarchicalDocType(options) {
+    return {
+        name: options.documentType,
+        title: 'Hierarchical tree',
+        type: 'document',
+        // The plugin needs to define a `schemaType` with liveEdit enabled so that
+        // `useDocumentOperation` in TreeDeskStructure.tsx doesn't create drafts at every patch.
+        liveEdit: true,
+        fields: [
+            createHierarchicalField({
+                name: options.fieldKeyInDocument || TreeDeskStructure_1.DEFAULT_FIELD_KEY,
+                title: 'Hierarchical Tree',
+                options: options
+            })
+        ],
+        preview: {
+            select: {
+                id: '_id',
+                tree: 'tree'
+            },
+            prepare: function (_a) {
+                var id = _a.id, tree = _a.tree;
+                return {
+                    title: "Hierarchical documents (ID: ".concat(id, ")"),
+                    subtitle: "".concat((tree === null || tree === void 0 ? void 0 : tree.length) || 0, " document(s) in its list.")
+                };
+            }
+        }
+    };
+}
+function createHierarchicalSchemas(options) {
+    if (!Array.isArray(options.referenceTo) || options.referenceTo.length <= 0) {
+        (0, throwError_1.default)('invalidReferenceTo');
+    }
+    if (!options.documentType) {
+        (0, throwError_1.default)('invalidDocumentType');
+    }
+    return [
+        createHierarchicalDocType(options),
+        createHierarchicalArrayType(options),
+        createHierarchicalNodeType(options),
+        createHierarchicalNodeValueType(options)
+    ];
+}
+exports.default = createHierarchicalSchemas;

package/lib/{utils → hooks}/useAllItems.d.ts

@@ -1,7 +1,7 @@
-import { AllItems, TreeInputOptions } from '../types';
-declare type Status = 'loading' | 'success' | 'error';
-export default function useAllItems(options: TreeInputOptions): {
-    status: Status;
-    allItems: AllItems;
-};
-export {};
+import { AllItems, TreeInputOptions } from '../types';
+declare type Status = 'loading' | 'success' | 'error';
+export default function useAllItems(options: TreeInputOptions): {
+    status: Status;
+    allItems: AllItems;
+};
+export {};

package/lib/{utils → hooks}/useAllItems.js

@@ -1,94 +1,119 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-import sanityClient from 'part:@sanity/base/client';
-import React from 'react';
-import { isDraft, unprefixId } from './idUtils';
-var client = sanityClient.withConfig({
-    apiVersion: '2021-09-01'
-});
-function getDeskFilter(_a) {
-    var referenceTo = _a.referenceTo, referenceOptions = _a.referenceOptions;
-    var filterParts = ['_type in $docTypes'];
-    if (referenceOptions === null || referenceOptions === void 0 ? void 0 : referenceOptions.filter) {
-        filterParts.push(referenceOptions.filter);
-    }
-    return {
-        filter: filterParts.join(' && '),
-        params: __assign(__assign({}, ((referenceOptions === null || referenceOptions === void 0 ? void 0 : referenceOptions.filterParams) || {})), { docTypes: referenceTo.map(function (schemaType) { return schemaType; }) })
-    };
-}
-function updateItemInState(state, item) {
-    var _a;
-    var newState = __assign({}, state);
-    var publishedId = unprefixId(item._id);
-    newState[publishedId] = __assign(__assign({}, (newState[publishedId] || {})), (_a = {}, _a[isDraft(item._id) ? 'draft' : 'published'] = item, _a));
-    return newState;
-}
-function allItemsReducer(state, action) {
-    var _a;
-    var _b, _c, _d;
-    if (action.type === 'addOrEditItem' && ((_b = action.item) === null || _b === void 0 ? void 0 : _b._id)) {
-        return updateItemInState(state, action.item);
-    }
-    if (action.type === 'removeItem') {
-        var publishedId = unprefixId(action.itemId);
-        return __assign(__assign({}, state), (_a = {}, _a[publishedId] = isDraft(action.itemId)
-            ? // If a draft, keep only published
-                {
-                    published: (_c = state[publishedId]) === null || _c === void 0 ? void 0 : _c.published
-                }
-            : {
-                draft: (_d = state[publishedId]) === null || _d === void 0 ? void 0 : _d.draft
-            }, _a));
-    }
-    if (action.type === 'setInitialData') {
-        return action.items.reduce(updateItemInState, {});
-    }
-    return state;
-}
-export default function useAllItems(options) {
-    var _a = React.useState('loading'), status = _a[0], setStatus = _a[1];
-    var _b = React.useReducer(allItemsReducer, {}), allItems = _b[0], dispatch = _b[1];
-    function handleListener(event) {
-        if (event.type !== 'mutation') {
-            return;
-        }
-        if (event.result) {
-            dispatch({ type: 'addOrEditItem', item: event.result });
-        }
-        else {
-            dispatch({ type: 'removeItem', itemId: event.documentId });
-        }
-    }
-    function handleFirstLoad(items) {
-        dispatch({ type: 'setInitialData', items: items });
-        setStatus('success');
-    }
-    React.useEffect(function () {
-        var _a = getDeskFilter(options), filter = _a.filter, params = _a.params;
-        var query = "*[".concat(filter, "] {\n      _id,\n      _type,\n      _updatedAt,\n    }");
-        client
-            .fetch(query, params)
-            .then(handleFirstLoad)
-            .catch(function () {
-            setStatus('error');
-        });
-        var listener = client.listen(query, params).subscribe(handleListener);
-        return function () {
-            listener.unsubscribe();
-        };
-    }, []);
-    return {
-        status: status,
-        allItems: allItems
-    };
-}
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var client_1 = __importDefault(require("part:@sanity/base/client"));
+var React = __importStar(require("react"));
+var idUtils_1 = require("../utils/idUtils");
+var client = client_1.default.withConfig({
+    apiVersion: '2021-09-01'
+});
+function getDeskFilter(_a) {
+    var referenceTo = _a.referenceTo, referenceOptions = _a.referenceOptions;
+    var filterParts = ['_type in $docTypes'];
+    if (referenceOptions === null || referenceOptions === void 0 ? void 0 : referenceOptions.filter) {
+        filterParts.push(referenceOptions.filter);
+    }
+    return {
+        filter: filterParts.join(' && '),
+        params: __assign(__assign({}, ((referenceOptions === null || referenceOptions === void 0 ? void 0 : referenceOptions.filterParams) || {})), { docTypes: referenceTo.map(function (schemaType) { return schemaType; }) })
+    };
+}
+function updateItemInState(state, item) {
+    var _a;
+    var newState = __assign({}, state);
+    var publishedId = (0, idUtils_1.unprefixId)(item._id);
+    newState[publishedId] = __assign(__assign({}, (newState[publishedId] || {})), (_a = {}, _a[(0, idUtils_1.isDraft)(item._id) ? 'draft' : 'published'] = item, _a));
+    return newState;
+}
+function allItemsReducer(state, action) {
+    var _a;
+    var _b, _c, _d;
+    if (action.type === 'addOrEditItem' && ((_b = action.item) === null || _b === void 0 ? void 0 : _b._id)) {
+        return updateItemInState(state, action.item);
+    }
+    if (action.type === 'removeItem') {
+        var publishedId = (0, idUtils_1.unprefixId)(action.itemId);
+        return __assign(__assign({}, state), (_a = {}, _a[publishedId] = (0, idUtils_1.isDraft)(action.itemId)
+            ? // If a draft, keep only published
+                {
+                    published: (_c = state[publishedId]) === null || _c === void 0 ? void 0 : _c.published
+                }
+            : {
+                draft: (_d = state[publishedId]) === null || _d === void 0 ? void 0 : _d.draft
+            }, _a));
+    }
+    if (action.type === 'setInitialData') {
+        return action.items.reduce(updateItemInState, {});
+    }
+    return state;
+}
+function useAllItems(options) {
+    var _a = React.useState('loading'), status = _a[0], setStatus = _a[1];
+    var _b = React.useReducer(allItemsReducer, {}), allItems = _b[0], dispatch = _b[1];
+    function handleListener(event) {
+        if (event.type !== 'mutation') {
+            return;
+        }
+        if (event.result) {
+            dispatch({ type: 'addOrEditItem', item: event.result });
+        }
+        else {
+            dispatch({ type: 'removeItem', itemId: event.documentId });
+        }
+    }
+    function handleFirstLoad(items) {
+        dispatch({ type: 'setInitialData', items: items });
+        setStatus('success');
+    }
+    React.useEffect(function () {
+        var _a = getDeskFilter(options), filter = _a.filter, params = _a.params;
+        var query = "*[".concat(filter, "] {\n      _id,\n      _type,\n      _updatedAt,\n    }");
+        client
+            .fetch(query, params)
+            .then(handleFirstLoad)
+            .catch(function () {
+            setStatus('error');
+        });
+        var listener = client.listen(query, params).subscribe(handleListener);
+        return function () {
+            listener.unsubscribe();
+        };
+    }, []);
+    return {
+        status: status,
+        allItems: allItems
+    };
+}
+exports.default = useAllItems;