@civet/core 1.0.0-rc8 → 1.2.0

package/lib/DataProvider.js

@@ -68,6 +68,14 @@ var DataProvider = /*#__PURE__*/function () {
   _createClass(DataProvider, [{
     key: "extend",
     value: function extend() {}
+  }, {
+    key: "createInstance",
+    value: function createInstance() {
+      return null;
+    }
+  }, {
+    key: "releaseInstance",
+    value: function releaseInstance() {}
   }, {
     key: "subscribe",
     value: function subscribe(resource, handler) {
@@ -171,8 +179,13 @@ var DataProvider = /*#__PURE__*/function () {
     }
   }, {
     key: "compareRequests",
-    value: function compareRequests(prev, next) {
-      return (0, _fastDeepEqual["default"])(prev, next);
+    value: function compareRequests(nextRequestDetails, prevRequestDetails) {
+      return (0, _fastDeepEqual["default"])(nextRequestDetails, prevRequestDetails);
+    }
+  }, {
+    key: "shouldPersist",
+    value: function shouldPersist(nextRequestDetails, prevRequestDetails, persistent) {
+      return persistent === 'very' || persistent && prevRequestDetails.name === nextRequestDetails.name;
     }
   }, {
     key: "compareItemVersions",
@@ -186,18 +199,18 @@ var DataProvider = /*#__PURE__*/function () {
     }
   }, {
     key: "transition",
-    value: function transition(nextData) {
-      return nextData;
+    value: function transition(nextContext) {
+      return nextContext.data;
     }
   }, {
     key: "recycleItems",
-    value: function recycleItems(nextData, prevData) {
+    value: function recycleItems(nextContext, prevContext) {
       var _this7 = this;
 
       var prevMapping = {};
 
-      if (nextData.length > 0) {
-        prevData.forEach(function (item) {
+      if (nextContext.data.length > 0) {
+        prevContext.data.forEach(function (item) {
           var id = _this7.getItemIdentifier(item);
 
           if (id != null) prevMapping[id] = item;
@@ -206,8 +219,8 @@ var DataProvider = /*#__PURE__*/function () {
 
       var result;
 
-      if (prevData.length > 0) {
-        result = nextData.map(function (nextItem) {
+      if (prevContext.data.length > 0) {
+        result = nextContext.data.map(function (nextItem) {
           var id = _this7.getItemIdentifier(nextItem);
 
           if (id != null && Object.prototype.hasOwnProperty.call(prevMapping, id)) {
@@ -218,13 +231,13 @@ var DataProvider = /*#__PURE__*/function () {
           return nextItem;
         });
       } else {
-        result = nextData;
+        result = nextContext.data;
       }
 
-      if (prevData.length === result.length && result.reduce(function (sum, item, i) {
-        return sum && Object.is(prevData[i], item);
+      if (prevContext.data.length === result.length && result.reduce(function (sum, item, i) {
+        return sum && Object.is(prevContext.data[i], item);
       }, true)) {
-        return prevData;
+        return prevContext.data;
       }
 
       return result;

package/lib/Meta.js

@@ -18,10 +18,11 @@ function _defineProperties(target, props) { for (var i = 0; i < props.length; i+
 function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
 
 var Meta = /*#__PURE__*/function () {
-  function Meta(base) {
+  function Meta(base, instance) {
     _classCallCheck(this, Meta);
 
     this.data = base == null ? {} : base;
+    this.instance = instance;
   }
 
   _createClass(Meta, [{

package/lib/uniqueIdentifier.js

@@ -22,7 +22,7 @@ function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 /**
  * Returns incrementing unique string identifiers.
  * Uniqueness is guaranteed for <Number.MAX_SAFE_INTEGER> iterations.
- * The values can be compared alphanumerically, as long as they do not exceed the previously specified iterations.
+ * The values can be compared alphanumerically, as long as they do not exceed the previously specified number of iterations.
  *
  * @param {string?} previous Previous identifier
  */

package/lib/useResource.js

@@ -15,8 +15,7 @@ var _Meta = _interopRequireDefault(require("./Meta"));
 
 var _uniqueIdentifier = _interopRequireDefault(require("./uniqueIdentifier"));
 
-var _excluded = ["dataProvider", "name", "query", "empty", "options", "persistent"],
-    _excluded2 = ["data"];
+var _excluded = ["dataProvider", "name", "query", "empty", "options", "persistent"];
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
@@ -53,19 +52,19 @@ function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) r
  */
 function useResource(_ref) {
   var dataProviderProp = _ref.dataProvider,
-      name = _ref.name,
-      query = _ref.query,
-      empty = _ref.empty,
-      options = _ref.options,
-      persistent = _ref.persistent,
+      nextName = _ref.name,
+      nextQuery = _ref.query,
+      nextEmpty = _ref.empty,
+      nextOptions = _ref.options,
+      nextPersistent = _ref.persistent,
       rest = _objectWithoutProperties(_ref, _excluded);
 
   var configContext = (0, _context2.useConfigContext)();
   var currentDataProvider = dataProviderProp || configContext.dataProvider;
 
-  var dataProvider = _react["default"].useMemo(function () {
-    return currentDataProvider;
-  }, []);
+  var _React$useState = _react["default"].useState(currentDataProvider),
+      _React$useState2 = _slicedToArray(_React$useState, 1),
+      dataProvider = _React$useState2[0];
 
   if (dataProvider == null) {
     throw new Error('Unmet requirement: The DataProvider for the useResource hook is missing - Check your ConfigContext provider and the dataProvider property');
@@ -75,86 +74,100 @@ function useResource(_ref) {
     throw new Error('Constant violation: The DataProvider provided to the useResource hook must not be replaced - Check your ConfigContext provider and the dataProvider property');
   }
 
-  var comparator = {
-    name: name,
-    query: query,
-    empty: empty,
-    options: options
-  };
+  var _React$useState3 = _react["default"].useState(function () {
+    return dataProvider.createInstance();
+  }),
+      _React$useState4 = _slicedToArray(_React$useState3, 1),
+      instance = _React$useState4[0];
 
-  var _React$useState = _react["default"].useState(function () {
+  _react["default"].useEffect(function () {
+    return function () {
+      dataProvider.releaseInstance(instance);
+    };
+  }, []);
+
+  var nextRequestDetails = _react["default"].useMemo(function () {
+    return {
+      name: nextName,
+      query: nextQuery,
+      empty: nextEmpty,
+      options: nextOptions
+    };
+  }, [nextName, nextQuery, nextEmpty, nextOptions]);
+
+  var _React$useState5 = _react["default"].useState(function () {
     var request = (0, _uniqueIdentifier["default"])();
     var revision = (0, _uniqueIdentifier["default"])();
     return {
-      comparator: comparator,
+      requestDetails: nextRequestDetails,
       request: request,
       revision: revision,
-      isLoading: !empty,
+      isLoading: !nextRequestDetails.empty,
       value: {
-        name: name,
-        query: query,
-        options: options,
+        name: nextRequestDetails.name,
+        query: nextRequestDetails.query,
+        options: nextRequestDetails.options,
         request: request,
         revision: revision,
         data: [],
         meta: {},
         error: undefined,
-        isEmpty: !!empty,
-        isIncomplete: !empty,
-        isInitial: !empty
+        isEmpty: !!nextRequestDetails.empty,
+        isIncomplete: !nextRequestDetails.empty,
+        isInitial: !nextRequestDetails.empty
       },
-      persistent: persistent
+      persistent: nextPersistent
     };
   }),
-      _React$useState2 = _slicedToArray(_React$useState, 2),
-      state = _React$useState2[0],
-      setState = _React$useState2[1];
+      _React$useState6 = _slicedToArray(_React$useState5, 2),
+      state = _React$useState6[0],
+      setState = _React$useState6[1];
 
-  var prevComparator = state.comparator,
+  var requestDetails = state.requestDetails,
       request = state.request,
       revision = state.revision,
       isLoading = state.isLoading,
       value = state.value,
-      prevPersistent = state.persistent;
+      persistent = state.persistent;
 
-  if (prevComparator !== comparator && !dataProvider.compareRequests(prevComparator, comparator)) {
+  if (requestDetails !== nextRequestDetails && !dataProvider.compareRequests(nextRequestDetails, requestDetails)) {
     setState(function (prevState) {
       var nextRequest = (0, _uniqueIdentifier["default"])(prevState.request);
       var nextRevision = (0, _uniqueIdentifier["default"])(prevState.revision);
-      var isPersistent;
+      var isPersistent = false;
 
-      if (prevState.value.meta.persistent === 'very' || persistent === 'very' && prevState.persistent === 'very') {
+      if (prevState.persistent === 'very' && nextPersistent === 'very') {
         isPersistent = 'very';
-      } else if (prevState.value.meta.persistent || persistent && prevState.persistent) {
+      } else if (prevState.persistent && nextPersistent) {
         isPersistent = true;
       }
 
-      var shouldValuePersist = !empty && isPersistent && (isPersistent === 'very' || prevState.comparator.name === comparator.name);
+      var shouldValuePersist = !nextRequestDetails.empty && dataProvider.shouldPersist(nextRequestDetails, prevState.requestDetails, isPersistent, prevState.value);
       return {
-        comparator: comparator,
+        requestDetails: nextRequestDetails,
         request: nextRequest,
         revision: nextRevision,
-        isLoading: !empty,
+        isLoading: !nextRequestDetails.empty,
         value: shouldValuePersist ? prevState.value : {
-          name: name,
-          query: query,
-          options: options,
+          name: nextRequestDetails.name,
+          query: nextRequestDetails.query,
+          options: nextRequestDetails.options,
           request: nextRequest,
           revision: nextRevision,
           data: [],
           meta: {},
           error: undefined,
-          isEmpty: !!empty,
-          isIncomplete: !empty,
-          isInitial: !empty
+          isEmpty: !!nextRequestDetails.empty,
+          isIncomplete: !nextRequestDetails.empty,
+          isInitial: !nextRequestDetails.empty
         },
-        persistent: persistent
+        persistent: nextPersistent
       };
     });
-  } else if (prevPersistent !== persistent) {
+  } else if (persistent !== nextPersistent) {
     setState(function (prevState) {
       return _objectSpread(_objectSpread({}, prevState), {}, {
-        persistent: persistent
+        persistent: nextPersistent
       });
     });
   }
@@ -189,15 +202,15 @@ function useResource(_ref) {
 
 
   _react["default"].useEffect(function () {
-    if (empty) return undefined;
-    var unsubscribe = dataProvider.subscribe(name, notify);
+    if (requestDetails.empty) return undefined;
+    var unsubscribe = dataProvider.subscribe(requestDetails.name, notify);
     return unsubscribe;
-  }, [!empty, dataProvider, name, notify]);
+  }, [requestDetails.empty, dataProvider, requestDetails.name, notify]);
 
   _react["default"].useEffect(function () {
-    if (empty) return undefined;
+    if (requestDetails.empty) return undefined;
     var abortSignal = new _AbortSignal["default"]();
-    var meta = new _Meta["default"](_objectSpread({}, value.meta));
+    var meta = new _Meta["default"](_objectSpread({}, value.meta), instance);
 
     var callback = function callback(error, done, data) {
       setState(function (prevState) {
@@ -213,32 +226,29 @@ function useResource(_ref) {
           });
         }
 
-        var _prevState$value = prevState.value,
-            prevData = _prevState$value.data,
-            prevContext = _objectWithoutProperties(_prevState$value, _excluded2);
-
         var context = {
-          name: name,
-          query: query,
-          options: options,
+          name: requestDetails.name,
+          query: requestDetails.query,
+          options: requestDetails.options,
           request: request,
           revision: revision,
-          meta: meta.commit(prevContext.meta),
+          data: data,
+          meta: meta.commit(prevState.value.meta),
           error: undefined,
           isEmpty: false,
           isIncomplete: !done,
           isInitial: !!prevState.isInitial && !done
         };
+        context.data = dataProvider.transition(context, prevState.value);
+        context.data = dataProvider.recycleItems(context, prevState.value);
         return _objectSpread(_objectSpread({}, prevState), {}, {
           isLoading: !done,
-          value: _objectSpread(_objectSpread({}, context), {}, {
-            data: dataProvider.recycleItems(dataProvider.transition(data, prevData, context, prevContext), prevData, context, prevContext)
-          })
+          value: context
         });
       });
     };
 
-    dataProvider.continuousGet(name, query, options, meta, callback, abortSignal);
+    dataProvider.continuousGet(requestDetails.name, requestDetails.query, requestDetails.options, meta, callback, abortSignal);
     return function () {
       abortSignal.abort();
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@civet/core",
-  "version": "1.0.0-rc8",
+  "version": "1.2.0",
   "description": "Civet",
   "main": "./lib/index.js",
   "scripts": {

package/src/DataProvider.js

@@ -42,6 +42,12 @@ class DataProvider {
 
   extend() {}
 
+  createInstance() {
+    return null;
+  }
+
+  releaseInstance() {}
+
   subscribe(resource, handler) {
     if (resource == null) throw new Error('No resource name specified');
     return this.notifier.subscribe(resource, handler);
@@ -127,8 +133,14 @@ class DataProvider {
     });
   }
 
-  compareRequests(prev, next) {
-    return deepEquals(prev, next);
+  compareRequests(nextRequestDetails, prevRequestDetails) {
+    return deepEquals(nextRequestDetails, prevRequestDetails);
+  }
+
+  shouldPersist(nextRequestDetails, prevRequestDetails, persistent) {
+    return (
+      persistent === 'very' || (persistent && prevRequestDetails.name === nextRequestDetails.name)
+    );
   }
 
   compareItemVersions() {
@@ -139,21 +151,21 @@ class DataProvider {
     return objectHash(item);
   }
 
-  transition(nextData) {
-    return nextData;
+  transition(nextContext) {
+    return nextContext.data;
   }
 
-  recycleItems(nextData, prevData) {
+  recycleItems(nextContext, prevContext) {
     const prevMapping = {};
-    if (nextData.length > 0) {
-      prevData.forEach((item) => {
+    if (nextContext.data.length > 0) {
+      prevContext.data.forEach((item) => {
         const id = this.getItemIdentifier(item);
         if (id != null) prevMapping[id] = item;
       });
     }
     let result;
-    if (prevData.length > 0) {
-      result = nextData.map((nextItem) => {
+    if (prevContext.data.length > 0) {
+      result = nextContext.data.map((nextItem) => {
         const id = this.getItemIdentifier(nextItem);
         if (id != null && Object.prototype.hasOwnProperty.call(prevMapping, id)) {
           const prevItem = prevMapping[id];
@@ -162,13 +174,13 @@ class DataProvider {
         return nextItem;
       });
     } else {
-      result = nextData;
+      result = nextContext.data;
     }
     if (
-      prevData.length === result.length &&
-      result.reduce((sum, item, i) => sum && Object.is(prevData[i], item), true)
+      prevContext.data.length === result.length &&
+      result.reduce((sum, item, i) => sum && Object.is(prevContext.data[i], item), true)
     ) {
-      return prevData;
+      return prevContext.data;
     }
     return result;
   }

package/src/Meta.js

@@ -1,6 +1,7 @@
 class Meta {
-  constructor(base) {
+  constructor(base, instance) {
     this.data = base == null ? {} : base;
+    this.instance = instance;
   }
 
   clear() {

package/src/uniqueIdentifier.js

@@ -3,7 +3,7 @@ import { v1 as uuid } from 'uuid';
 /**
  * Returns incrementing unique string identifiers.
  * Uniqueness is guaranteed for <Number.MAX_SAFE_INTEGER> iterations.
- * The values can be compared alphanumerically, as long as they do not exceed the previously specified iterations.
+ * The values can be compared alphanumerically, as long as they do not exceed the previously specified number of iterations.
  *
  * @param {string?} previous Previous identifier
  */

package/src/useResource.js

@@ -12,16 +12,16 @@ import uniqueIdentifier from './uniqueIdentifier';
  */
 function useResource({
   dataProvider: dataProviderProp,
-  name,
-  query,
-  empty,
-  options,
-  persistent,
+  name: nextName,
+  query: nextQuery,
+  empty: nextEmpty,
+  options: nextOptions,
+  persistent: nextPersistent,
   ...rest
 }) {
   const configContext = useConfigContext();
   const currentDataProvider = dataProviderProp || configContext.dataProvider;
-  const dataProvider = React.useMemo(() => currentDataProvider, []);
+  const [dataProvider] = React.useState(currentDataProvider);
   if (dataProvider == null) {
     throw new Error(
       'Unmet requirement: The DataProvider for the useResource hook is missing - Check your ConfigContext provider and the dataProvider property',
@@ -33,82 +33,90 @@ function useResource({
     );
   }
 
-  const comparator = { name, query, empty, options };
+  const [instance] = React.useState(() => dataProvider.createInstance());
+  React.useEffect(
+    () => () => {
+      dataProvider.releaseInstance(instance);
+    },
+    [],
+  );
+
+  const nextRequestDetails = React.useMemo(
+    () => ({ name: nextName, query: nextQuery, empty: nextEmpty, options: nextOptions }),
+    [nextName, nextQuery, nextEmpty, nextOptions],
+  );
   const [state, setState] = React.useState(() => {
     const request = uniqueIdentifier();
     const revision = uniqueIdentifier();
     return {
-      comparator,
+      requestDetails: nextRequestDetails,
       request,
       revision,
-      isLoading: !empty,
+      isLoading: !nextRequestDetails.empty,
       value: {
-        name,
-        query,
-        options,
+        name: nextRequestDetails.name,
+        query: nextRequestDetails.query,
+        options: nextRequestDetails.options,
         request,
         revision,
         data: [],
         meta: {},
         error: undefined,
-        isEmpty: !!empty,
-        isIncomplete: !empty,
-        isInitial: !empty,
+        isEmpty: !!nextRequestDetails.empty,
+        isIncomplete: !nextRequestDetails.empty,
+        isInitial: !nextRequestDetails.empty,
       },
-      persistent,
+      persistent: nextPersistent,
     };
   });
-  const {
-    comparator: prevComparator,
-    request,
-    revision,
-    isLoading,
-    value,
-    persistent: prevPersistent,
-  } = state;
-
-  if (prevComparator !== comparator && !dataProvider.compareRequests(prevComparator, comparator)) {
+  const { requestDetails, request, revision, isLoading, value, persistent } = state;
+
+  if (
+    requestDetails !== nextRequestDetails &&
+    !dataProvider.compareRequests(nextRequestDetails, requestDetails)
+  ) {
     setState((prevState) => {
       const nextRequest = uniqueIdentifier(prevState.request);
       const nextRevision = uniqueIdentifier(prevState.revision);
-      let isPersistent;
-      if (
-        prevState.value.meta.persistent === 'very' ||
-        (persistent === 'very' && prevState.persistent === 'very')
-      ) {
+      let isPersistent = false;
+      if (prevState.persistent === 'very' && nextPersistent === 'very') {
         isPersistent = 'very';
-      } else if (prevState.value.meta.persistent || (persistent && prevState.persistent)) {
+      } else if (prevState.persistent && nextPersistent) {
         isPersistent = true;
       }
       const shouldValuePersist =
-        !empty &&
-        isPersistent &&
-        (isPersistent === 'very' || prevState.comparator.name === comparator.name);
+        !nextRequestDetails.empty &&
+        dataProvider.shouldPersist(
+          nextRequestDetails,
+          prevState.requestDetails,
+          isPersistent,
+          prevState.value,
+        );
       return {
-        comparator,
+        requestDetails: nextRequestDetails,
         request: nextRequest,
         revision: nextRevision,
-        isLoading: !empty,
+        isLoading: !nextRequestDetails.empty,
         value: shouldValuePersist
           ? prevState.value
           : {
-              name,
-              query,
-              options,
+              name: nextRequestDetails.name,
+              query: nextRequestDetails.query,
+              options: nextRequestDetails.options,
               request: nextRequest,
               revision: nextRevision,
               data: [],
               meta: {},
               error: undefined,
-              isEmpty: !!empty,
-              isIncomplete: !empty,
-              isInitial: !empty,
+              isEmpty: !!nextRequestDetails.empty,
+              isIncomplete: !nextRequestDetails.empty,
+              isInitial: !nextRequestDetails.empty,
             },
-        persistent,
+        persistent: nextPersistent,
       };
     });
-  } else if (prevPersistent !== persistent) {
-    setState((prevState) => ({ ...prevState, persistent }));
+  } else if (persistent !== nextPersistent) {
+    setState((prevState) => ({ ...prevState, persistent: nextPersistent }));
   }
 
   const notify = React.useCallback(
@@ -126,18 +134,18 @@ function useResource({
 
   // DataProvider events
   React.useEffect(() => {
-    if (empty) return undefined;
+    if (requestDetails.empty) return undefined;
 
-    const unsubscribe = dataProvider.subscribe(name, notify);
+    const unsubscribe = dataProvider.subscribe(requestDetails.name, notify);
     return unsubscribe;
-  }, [!empty, dataProvider, name, notify]);
+  }, [requestDetails.empty, dataProvider, requestDetails.name, notify]);
 
   React.useEffect(() => {
-    if (empty) return undefined;
+    if (requestDetails.empty) return undefined;
 
     const abortSignal = new AbortSignal();
 
-    const meta = new Meta({ ...value.meta });
+    const meta = new Meta({ ...value.meta }, instance);
 
     const callback = (error, done, data) => {
       setState((prevState) => {
@@ -155,37 +163,38 @@ function useResource({
           };
         }
 
-        const { data: prevData, ...prevContext } = prevState.value;
         const context = {
-          name,
-          query,
-          options,
+          name: requestDetails.name,
+          query: requestDetails.query,
+          options: requestDetails.options,
           request,
           revision,
-          meta: meta.commit(prevContext.meta),
+          data,
+          meta: meta.commit(prevState.value.meta),
           error: undefined,
           isEmpty: false,
           isIncomplete: !done,
           isInitial: !!prevState.isInitial && !done,
         };
+        context.data = dataProvider.transition(context, prevState.value);
+        context.data = dataProvider.recycleItems(context, prevState.value);
 
         return {
           ...prevState,
           isLoading: !done,
-          value: {
-            ...context,
-            data: dataProvider.recycleItems(
-              dataProvider.transition(data, prevData, context, prevContext),
-              prevData,
-              context,
-              prevContext,
-            ),
-          },
+          value: context,
         };
       });
     };
 
-    dataProvider.continuousGet(name, query, options, meta, callback, abortSignal);
+    dataProvider.continuousGet(
+      requestDetails.name,
+      requestDetails.query,
+      requestDetails.options,
+      meta,
+      callback,
+      abortSignal,
+    );
 
     return () => {
       abortSignal.abort();