@civet/core 0.6.9 → 1.0.0-rc1

package/lib/useResource.js

@@ -0,0 +1,265 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports["default"] = void 0;
+
+var _react = _interopRequireDefault(require("react"));
+
+var _AbortSignal = _interopRequireDefault(require("./AbortSignal"));
+
+var _context2 = require("./context");
+
+var _Meta = _interopRequireDefault(require("./Meta"));
+
+var _uniqueIdentifier = _interopRequireDefault(require("./uniqueIdentifier"));
+
+var _excluded = ["name", "query", "empty", "options", "provider", "persistent"],
+    _excluded2 = ["data"];
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+
+function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"]; if (_i == null) return; var _arr = []; var _n = true; var _d = false; var _s, _e; try { for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+/**
+ * Makes data from an DataProvider available.
+ * If not explicitly specified, necessary configuration is taken from the nearest <ConfigProvider>.
+ * The provided DataProvider must not be replaced.
+ */
+function useResource(props) {
+  var name = props.name,
+      query = props.query,
+      empty = props.empty,
+      options = props.options,
+      providerProp = props.provider,
+      persistent = props.persistent,
+      rest = _objectWithoutProperties(props, _excluded);
+
+  var configContext = (0, _context2.useConfigContext)();
+  var currentProvider = providerProp || configContext.provider;
+
+  var provider = _react["default"].useMemo(function () {
+    return currentProvider;
+  }, []);
+
+  if (provider == null) {
+    throw new Error('Unmet requirement: The DataProvider for the useResource hook is missing - Check your ConfigContext and the provider property');
+  }
+
+  if (provider !== currentProvider) {
+    throw new Error('Constant violation: The DataProvider provided to the useResource hook must not be replaced - Check your ConfigContext and the provider property');
+  }
+
+  var comparator = {
+    name: name,
+    query: query,
+    empty: empty,
+    options: options
+  };
+
+  var _React$useState = _react["default"].useState(function () {
+    var request = (0, _uniqueIdentifier["default"])();
+    var revision = (0, _uniqueIdentifier["default"])();
+    return {
+      comparator: comparator,
+      request: request,
+      revision: revision,
+      isLoading: !empty,
+      value: {
+        name: name,
+        query: query,
+        options: options,
+        request: request,
+        revision: revision,
+        data: [],
+        meta: {},
+        error: undefined,
+        isEmpty: empty,
+        isIncomplete: !empty,
+        isInitial: !empty
+      },
+      persistent: persistent
+    };
+  }),
+      _React$useState2 = _slicedToArray(_React$useState, 2),
+      state = _React$useState2[0],
+      setState = _React$useState2[1];
+
+  var prevComparator = state.comparator,
+      request = state.request,
+      revision = state.revision,
+      isLoading = state.isLoading,
+      value = state.value,
+      prevPersistent = state.persistent;
+
+  if (prevComparator !== comparator && !provider.compareRequests(prevComparator, comparator)) {
+    setState(function (prevState) {
+      var nextRequest = (0, _uniqueIdentifier["default"])(prevState.request);
+      var nextRevision = (0, _uniqueIdentifier["default"])(prevState.revision);
+      var isPersistent;
+
+      if (prevState.value.meta.persistent === 'very' || persistent === 'very' && prevState.persistent === 'very') {
+        isPersistent = 'very';
+      } else if (prevState.value.meta.persistent || persistent && prevState.persistent) {
+        isPersistent = true;
+      }
+
+      var shouldValuePersist = !empty && isPersistent && (isPersistent === 'very' || prevState.comparator.name === comparator.name);
+      return {
+        comparator: comparator,
+        request: nextRequest,
+        revision: nextRevision,
+        isLoading: !empty,
+        value: shouldValuePersist ? prevState.value : {
+          name: name,
+          query: query,
+          options: options,
+          request: nextRequest,
+          revision: nextRevision,
+          data: [],
+          meta: {},
+          error: undefined,
+          isEmpty: empty,
+          isIncomplete: !empty,
+          isInitial: !empty
+        },
+        persistent: persistent
+      };
+    });
+  } else if (prevPersistent !== persistent) {
+    setState(function (prevState) {
+      return _objectSpread(_objectSpread({}, prevState), {}, {
+        persistent: persistent
+      });
+    });
+  }
+
+  var notify = _react["default"].useCallback( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() {
+    return regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            return _context.abrupt("return", new Promise(function (resolve) {
+              setState(function (currentState) {
+                if (currentState.empty) return currentState;
+                var nextRevision = (0, _uniqueIdentifier["default"])(currentState.revision);
+                resolve({
+                  request: currentState.request,
+                  revision: nextRevision
+                });
+                return _objectSpread(_objectSpread({}, currentState), {}, {
+                  isLoading: true,
+                  revision: nextRevision
+                });
+              });
+            }));
+
+          case 1:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  })), []); // DataProvider events
+
+
+  _react["default"].useEffect(function () {
+    if (empty) return undefined;
+    var unsubscribe = provider.subscribe(name, notify);
+    return unsubscribe;
+  }, [!empty, provider, name, notify]);
+
+  _react["default"].useEffect(function () {
+    if (empty) return undefined;
+    var abortSignal = new _AbortSignal["default"]();
+    var meta = new _Meta["default"](_objectSpread({}, value.meta));
+
+    var callback = function callback(error, done, data) {
+      setState(function (prevState) {
+        if (request !== prevState.request || revision !== prevState.revision) return prevState;
+
+        if (error != null) {
+          return _objectSpread(_objectSpread({}, prevState), {}, {
+            isLoading: false,
+            value: _objectSpread(_objectSpread({}, prevState.value), {}, {
+              error: error,
+              isIncomplete: false
+            })
+          });
+        }
+
+        var _prevState$value = prevState.value,
+            prevData = _prevState$value.data,
+            prevContext = _objectWithoutProperties(_prevState$value, _excluded2);
+
+        var context = {
+          name: name,
+          query: query,
+          options: options,
+          request: request,
+          revision: revision,
+          meta: meta.commit(prevContext.meta),
+          error: undefined,
+          isEmpty: false,
+          isIncomplete: !done,
+          isInitial: prevState.isInitial && !done
+        };
+        return {
+          isLoading: !done,
+          value: _objectSpread(_objectSpread({}, context), {}, {
+            data: provider.recycleItems(provider.transition(data, prevData, context, prevContext), prevData, context, prevContext)
+          })
+        };
+      });
+    };
+
+    provider.continuousGet(name, query, options, meta, callback, abortSignal);
+    return function () {
+      abortSignal.abort();
+    };
+  }, [request, revision]);
+
+  var isStale = request !== value.request;
+
+  var context = _react["default"].useMemo(function () {
+    return _objectSpread(_objectSpread({}, value), {}, {
+      provider: provider,
+      isLoading: isLoading,
+      isStale: isStale,
+      notify: notify
+    });
+  }, [value, provider, isLoading, isStale, notify]);
+
+  var contextPlugins = Array.isArray(provider.contextPlugins) ? provider.contextPlugins : [];
+  return contextPlugins.reduce(function (result, fn) {
+    return fn(result, rest);
+  }, context);
+}
+
+var _default = useResource;
+exports["default"] = _default;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@civet/core",
-  "version": "0.6.9",
+  "version": "1.0.0-rc1",
   "description": "Civet",
   "main": "./lib/index.js",
   "scripts": {
@@ -52,8 +52,8 @@
     "eslint-plugin-react": "^7.21.5",
     "eslint-plugin-react-hooks": "^4.2.0",
     "prettier": "^2.3.2",
-    "react": "*",
-    "react-dom": "*",
+    "react": "^18.1.0",
+    "react-dom": "^18.1.0",
     "rimraf": "^3.0.2"
   },
   "peerDependencies": {
@@ -62,8 +62,8 @@
   },
   "dependencies": {
     "fast-deep-equal": "^3.1.3",
-    "object-hash": "^2.2.0",
-    "prop-types": "^15.7.2",
+    "object-hash": "^3.0.0",
+    "prop-types": "^15.8.1",
     "uuid": "^8.3.2"
   }
 }

package/src/AbortSignal.js

@@ -3,11 +3,24 @@ import Notifier from './Notifier';
 class AbortSignal {
   constructor() {
     this.notifier = new Notifier();
-    this.locked = false;
-    this.aborted = false;
+    Object.defineProperties(this, {
+      locked: {
+        value: false,
+        enumerable: true,
+        writable: false,
+        configurable: true,
+      },
+      aborted: {
+        value: false,
+        enumerable: true,
+        writable: false,
+        configurable: true,
+      },
+    });
   }
 
   listen(cb) {
+    if (this.locked) return () => {};
     const alreadySubscribed = this.notifier.isSubscribed(cb);
     const unsubscribe = this.notifier.subscribe(cb);
     if (this.aborted && !alreadySubscribed) cb();
@@ -16,13 +29,39 @@ class AbortSignal {
 
   abort() {
     if (this.locked) return;
-    this.locked = true;
-    this.aborted = true;
+    this.lock();
+    Object.defineProperty(this, 'aborted', {
+      value: true,
+      enumerable: true,
+      writable: false,
+      configurable: false,
+    });
     this.notifier.trigger();
   }
 
   lock() {
-    this.locked = true;
+    if (this.locked) return;
+    Object.defineProperty(this, 'locked', {
+      value: true,
+      enumerable: true,
+      writable: false,
+      configurable: false,
+    });
+  }
+
+  proxy() {
+    const s = this;
+    return {
+      get notifier() {
+        return s.notifier;
+      },
+      get locked() {
+        return s.locked;
+      },
+      get aborted() {
+        return s.locked;
+      },
+    };
   }
 }
 

package/src/ConfigProvider.js

@@ -1,20 +1,20 @@
 import PropTypes from 'prop-types';
-import React, { useMemo } from 'react';
+import React from 'react';
 
 import { ConfigContext } from './context';
-import { dataStorePropType } from './DataStore';
+import { dataProviderPropType } from './DataProvider';
 
 /**
  * Provides general configuration to its descendants using React's context API.
  */
-function ConfigProvider({ dataStore, children }) {
-  const context = useMemo(() => ({ dataStore }), [dataStore]);
+function ConfigProvider({ provider, children }) {
+  const context = React.useMemo(() => ({ provider }), [provider]);
 
   return <ConfigContext.Provider value={context}>{children}</ConfigContext.Provider>;
 }
 
 ConfigProvider.propTypes = {
-  dataStore: dataStorePropType,
+  provider: dataProviderPropType,
   children: PropTypes.node,
 };
 

package/src/DataProvider.js

@@ -0,0 +1,182 @@
+import deepEquals from 'fast-deep-equal';
+import objectHash from 'object-hash';
+import PropTypes from 'prop-types';
+
+import AbortSignal from './AbortSignal';
+import ChannelNotifier from './ChannelNotifier';
+import Meta from './Meta';
+
+const getMeta = (meta) => (meta instanceof Meta ? meta : new Meta(meta));
+
+class DataProvider {
+  notifier = new ChannelNotifier();
+
+  constructor() {
+    const contextPlugins = [];
+    const uiPlugins = [];
+    this.extend({
+      context: (plugin) => {
+        const plugins = contextPlugins;
+        if (plugin != null && !plugins.includes(plugin)) plugins.push(plugin);
+      },
+      ui: (plugin) => {
+        const plugins = uiPlugins;
+        if (plugin != null && !plugins.includes(plugin)) plugins.push(plugin);
+      },
+    });
+    Object.defineProperties(this, {
+      contextPlugins: {
+        value: Object.freeze(contextPlugins.slice()),
+        enumerable: true,
+        writable: false,
+        configurable: false,
+      },
+      uiPlugins: {
+        value: Object.freeze(uiPlugins.slice()),
+        enumerable: true,
+        writable: false,
+        configurable: false,
+      },
+    });
+  }
+
+  extend() {}
+
+  subscribe(resource, handler) {
+    if (resource == null) throw new Error('No resource name specified');
+    return this.notifier.subscribe(resource, handler);
+  }
+
+  notify(resource) {
+    this.notifier.trigger(resource);
+  }
+
+  get(resource, query, options, meta) {
+    return new Promise((resolve, reject) =>
+      this.continuousGet(resource, query, options, meta, (error, done, result) => {
+        if (error != null) {
+          reject(error);
+          return;
+        }
+        if (done) resolve(result);
+      }),
+    );
+  }
+
+  continuousGet(resource, query, options, meta, callback, abortSignal) {
+    const signal = abortSignal == null ? new AbortSignal() : abortSignal;
+
+    new Promise((resolve) => {
+      if (resource == null) throw new Error('No resource name specified');
+
+      // result transformation
+      const cb = (error, done, result) => {
+        // prevent updates after completion
+        if (signal.locked) return;
+        if (error != null || done) {
+          signal.lock();
+        }
+        if (error != null) callback(error, true, []);
+        else if (result == null) callback(undefined, done, []);
+        else if (Array.isArray(result)) callback(undefined, done, result);
+        else callback(undefined, done, [result]);
+      };
+
+      resolve(
+        Promise.resolve(this.handleGet(resource, query, options, getMeta(meta))).then((result) => {
+          if (typeof result === 'function') {
+            result(cb, signal.proxy());
+          } else {
+            cb(undefined, true, result);
+          }
+        }),
+      );
+    }).catch((e) => {
+      if (!signal.locked) callback(e, true, []);
+    });
+  }
+
+  create(resource, data, options, meta) {
+    return new Promise((resolve) => {
+      if (resource == null) throw new Error('No resource name specified');
+      if (data == null) throw new Error('No data specified');
+      resolve(Promise.resolve(this.handleCreate(resource, data, options, getMeta(meta))));
+    });
+  }
+
+  update(resource, query, data, options, meta) {
+    return new Promise((resolve) => {
+      if (resource == null) throw new Error('No resource name specified');
+      if (data == null) throw new Error('No data specified');
+      resolve(Promise.resolve(this.handleUpdate(resource, query, data, options, getMeta(meta))));
+    });
+  }
+
+  patch(resource, query, data, options, meta) {
+    return new Promise((resolve) => {
+      if (resource == null) throw new Error('No resource name specified');
+      if (data == null) throw new Error('No data specified');
+      resolve(Promise.resolve(this.handlePatch(resource, query, data, options, getMeta(meta))));
+    });
+  }
+
+  remove(resource, query, options, meta) {
+    return new Promise((resolve) => {
+      if (resource == null) throw new Error('No resource name specified');
+      resolve(Promise.resolve(this.handleRemove(resource, query, options, getMeta(meta))));
+    });
+  }
+
+  compareRequests(prev, next) {
+    return deepEquals(prev, next);
+  }
+
+  compareItemVersions() {
+    return true;
+  }
+
+  getItemIdentifier(item) {
+    return objectHash(item);
+  }
+
+  transition(nextData) {
+    return nextData;
+  }
+
+  recycleItems(nextData, prevData) {
+    const prevMapping = {};
+    if (nextData.length > 0) {
+      prevData.forEach((item) => {
+        const id = this.getItemIdentifier(item);
+        if (id != null) prevMapping[id] = item;
+      });
+    }
+    let result;
+    if (prevData.length > 0) {
+      result = nextData.map((nextItem) => {
+        const id = this.getItemIdentifier(nextItem);
+        if (id != null && Object.prototype.hasOwnProperty.call(prevMapping, id)) {
+          const prevItem = prevMapping[id];
+          if (this.compareItemVersions(nextItem, prevItem)) return prevItem;
+        }
+        return nextItem;
+      });
+    } else {
+      result = nextData;
+    }
+    if (
+      prevData.length === result.length &&
+      result.reduce((sum, item, i) => sum && Object.is(prevData[i], item), true)
+    ) {
+      return prevData;
+    }
+    return result;
+  }
+}
+
+const isDataProvider = (provider) => provider instanceof DataProvider;
+
+const dataProviderPropType = PropTypes.instanceOf(DataProvider);
+
+export default DataProvider;
+export { isDataProvider, dataProviderPropType };

package/src/Meta.js

@@ -39,8 +39,11 @@ class Meta {
     return Object.values(this.data);
   }
 
-  commit(prev) {
+  commit(prev, ignore) {
     const next = { ...this.data };
+    (ignore || []).forEach((item) => {
+      delete next[item];
+    });
     const keys = Object.keys(next);
     if (
       prev != null &&