relay-forms-nodeps 1.0.0

package/lib/es/useFormSubmit.js

@@ -0,0 +1,105 @@
+import React from 'react';
+import { useStore } from './relay/RelayStoreProvider';
+import { isPromise } from './relay/RelayStoreUtils';
+import { commitValidateEndRelay, commitValidateIntoRelay, commitSubmitEndRelay, operationQueryForm, commitResetIntoRelay } from './Utils';
+export var useFormSubmit = function (_a) {
+  var onSubmit = _a.onSubmit;
+  var environment = useStore();
+  React.useEffect(function () {
+    return environment.retain(operationQueryForm).dispose;
+  }, [environment]);
+  var ref = React.useRef({
+    isSubmitting: false,
+    isValidating: false,
+    error: undefined,
+    subscription: undefined
+  });
+  var internalValidate = React.useCallback(function (snapshot, isSubmitting) {
+    ref.current.isValidating = true;
+    var data = snapshot.data;
+    var filtered = data.form.entries.filter(function (value) {
+      return value.check === 'INIT';
+    });
+    commitValidateIntoRelay(filtered, isSubmitting, environment);
+  }, [environment]);
+  var execute = React.useCallback(function (environment, snapshot, dispose, onSubmit) {
+    var data = snapshot.data;
+    var entries = data.form.entries;
+    var filtered = entries.filter(function (value) {
+      return value.check === 'DONE';
+    });
+    if (filtered.length === entries.length) {
+      var errors = entries.filter(function (value) {
+        return !!value.error;
+      });
+      commitValidateEndRelay(environment);
+      ref.current.isValidating = false;
+      var internalDispose = function () {
+        dispose();
+        if (ref.current.isSubmitting) {
+          ref.current.isSubmitting = false;
+          commitSubmitEndRelay(environment);
+        }
+      };
+      if (ref.current.isSubmitting && onSubmit && errors.length === 0) {
+        var result_1 = {};
+        entries.forEach(function (entry) {
+          result_1[entry.key] = entry.value;
+        });
+        var submit_1 = onSubmit(result_1);
+        if (isPromise(submit_1)) {
+          submit_1.then(internalDispose).catch(internalDispose);
+          return;
+        }
+      }
+      internalDispose();
+    }
+  }, []);
+  var reset = React.useCallback(function () {
+    var snapshot = environment.lookup(operationQueryForm.fragment);
+    if (ref.current.isValidating && ref.current.isSubmitting) {
+      return;
+    }
+    var data = snapshot.data;
+    commitResetIntoRelay(data.form.entries, environment);
+  }, [environment]);
+  var subscribe = React.useCallback(function (submit) {
+    if (submit === void 0) {
+      submit = false;
+    }
+    var snapshot = environment.lookup(operationQueryForm.fragment);
+    var subscription = ref.current.subscription;
+    subscription && subscription.dispose();
+    function dispose() {
+      subscription && subscription.dispose();
+      ref.current.subscription = null;
+    }
+    ref.current.subscription = environment.subscribe(snapshot, function (s) {
+      return execute(environment, s, dispose, onSubmit);
+    });
+    internalValidate(snapshot, submit);
+    execute(environment, snapshot, dispose, onSubmit);
+  }, [environment, internalValidate, execute, onSubmit]);
+  var validate = React.useCallback(function () {
+    if (!ref.current.isValidating) {
+      subscribe(false);
+    }
+  }, [subscribe]);
+  var submit = React.useCallback(function (event) {
+    if (event) {
+      event.preventDefault();
+    }
+    if (!ref.current.isSubmitting) {
+      ref.current.isSubmitting = true;
+      subscribe(true);
+    }
+  }, [subscribe]);
+  var result = React.useMemo(function () {
+    return {
+      submit: submit,
+      validate: validate,
+      reset: reset
+    };
+  }, [submit, validate, reset]);
+  return result;
+};

package/lib/es/useFormValue.d.ts

@@ -0,0 +1,2 @@
+import { FormValueStateReturn } from './RelayFormsTypes';
+export declare function useFormValue<ValueType>(key: string): FormValueStateReturn<ValueType>;

package/lib/es/useFormValue.js

@@ -0,0 +1,19 @@
+import React from 'react';
+import { FragmentValue } from './relay/queries';
+import { useStore } from './relay/RelayStoreProvider';
+import { getSnapshot } from './Utils';
+export function useFormValue(key) {
+  var environment = useStore();
+  var snapshot = React.useMemo(function () {
+    return getSnapshot(environment, FragmentValue, key);
+  }, [key, environment]);
+  var _a = React.useState(snapshot.data),
+    data = _a[0],
+    setData = _a[1];
+  React.useEffect(function () {
+    return environment.subscribe(snapshot, function (s) {
+      setData(s.data);
+    }).dispose;
+  }, [environment, snapshot, setData]);
+  return data;
+}

package/lib/index.d.ts

@@ -0,0 +1,9 @@
+export { useFormState } from './useFormState';
+export { useFormSubmit } from './useFormSubmit';
+export { useFormSetValue } from './useFormSetValue';
+export { useFormValue } from './useFormValue';
+export { StoreProvider } from './relay/RelayStoreProvider';
+export { RelayModernStore as Store, createStore } from './relay/RelayModernStore';
+export { RelayRecordSource as RecordSource } from './relay/RelayRecordSource';
+export * from './RelayFormsTypes';
+export * from './relay/RelayTypes';

package/lib/index.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var useFormState_1 = require("./useFormState");
+exports.useFormState = useFormState_1.useFormState;
+var useFormSubmit_1 = require("./useFormSubmit");
+exports.useFormSubmit = useFormSubmit_1.useFormSubmit;
+var useFormSetValue_1 = require("./useFormSetValue");
+exports.useFormSetValue = useFormSetValue_1.useFormSetValue;
+var useFormValue_1 = require("./useFormValue");
+exports.useFormValue = useFormValue_1.useFormValue;
+var RelayStoreProvider_1 = require("./relay/RelayStoreProvider");
+exports.StoreProvider = RelayStoreProvider_1.StoreProvider;
+var RelayModernStore_1 = require("./relay/RelayModernStore");
+exports.Store = RelayModernStore_1.RelayModernStore;
+exports.createStore = RelayModernStore_1.createStore;
+var RelayRecordSource_1 = require("./relay/RelayRecordSource");
+exports.RecordSource = RelayRecordSource_1.RelayRecordSource;

package/lib/relay/RelayModernRecord.d.ts

@@ -0,0 +1,107 @@
+/**
+ * @public
+ *
+ * Low-level record manipulation methods.
+ *
+ * A note about perf: we use long-hand property access rather than computed
+ * properties in this file for speed ie.
+ *
+ *    const object = {};
+ *    object[KEY] = value;
+ *    record[storageKey] = object;
+ *
+ * instead of:
+ *
+ *    record[storageKey] = {
+ *      [KEY]: value,
+ *    };
+ *
+ * The latter gets transformed by Babel into something like:
+ *
+ *    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;
+ *    }
+ *
+ *    record[storageKey] = _defineProperty({}, KEY, value);
+ *
+ * A quick benchmark shows that computed property access is an order of
+ * magnitude slower (times in seconds for 100,000 iterations):
+ *
+ *               best     avg     sd
+ *    computed 0.02175 0.02292 0.00113
+ *      manual 0.00110 0.00123 0.00008
+ */
+/**
+ * @public
+ *
+ * Create a new record.
+ */
+declare function create(dataID: any): {};
+/**
+ * @public
+ *
+ * Get a scalar (non-link) field value.
+ */
+declare function getValue(record: any, storageKey: any): any;
+/**
+ * @public
+ *
+ * Get the value of a field as a reference to another record. Throws if the
+ * field has a different type.
+ */
+declare function getLinkedRecordID(record: any, storageKey: any): any;
+/**
+ * @public
+ *
+ * Get the value of a field as a list of references to other records. Throws if
+ * the field has a different type.
+ */
+declare function getLinkedRecordIDs(record: any, storageKey: string): any;
+/**
+ * @public
+ *
+ * Compares the fields of a previous and new record, returning either the
+ * previous record if all fields are equal or a new record (with merged fields)
+ * if any fields have changed.
+ */
+declare function update(prevRecord: any, nextRecord: any): any;
+/**
+ * @public
+ *
+ * Set the value of a storageKey to a scalar.
+ * YES
+ */
+declare function setValue(record: any, storageKey: any, value: any): void;
+/**
+ * @public
+ *
+ * Set the value of a field to a reference to another record.
+ */
+declare function setLinkedRecordID(record: any, storageKey: string, linkedID: any): void;
+/**
+ * @public
+ *
+ * Set the value of a field to a list of references other records.
+ */
+declare function setLinkedRecordIDs(record: any, storageKey: string, linkedIDs: any): void;
+export declare const RelayModernRecord: {
+    create: typeof create;
+    getLinkedRecordID: typeof getLinkedRecordID;
+    getLinkedRecordIDs: typeof getLinkedRecordIDs;
+    getValue: typeof getValue;
+    setValue: typeof setValue;
+    setLinkedRecordID: typeof setLinkedRecordID;
+    setLinkedRecordIDs: typeof setLinkedRecordIDs;
+    update: typeof update;
+};
+export {};

package/lib/relay/RelayModernRecord.js

@@ -0,0 +1,188 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+/* eslint-disable @typescript-eslint/explicit-function-return-type */
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+var RelayStoreUtils_1 = require("./RelayStoreUtils");
+var ID_KEY = RelayStoreUtils_1.RelayStoreUtils.ID_KEY,
+  REF_KEY = RelayStoreUtils_1.RelayStoreUtils.REF_KEY,
+  REFS_KEY = RelayStoreUtils_1.RelayStoreUtils.REFS_KEY;
+/**
+ * @public
+ *
+ * Low-level record manipulation methods.
+ *
+ * A note about perf: we use long-hand property access rather than computed
+ * properties in this file for speed ie.
+ *
+ *    const object = {};
+ *    object[KEY] = value;
+ *    record[storageKey] = object;
+ *
+ * instead of:
+ *
+ *    record[storageKey] = {
+ *      [KEY]: value,
+ *    };
+ *
+ * The latter gets transformed by Babel into something like:
+ *
+ *    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;
+ *    }
+ *
+ *    record[storageKey] = _defineProperty({}, KEY, value);
+ *
+ * A quick benchmark shows that computed property access is an order of
+ * magnitude slower (times in seconds for 100,000 iterations):
+ *
+ *               best     avg     sd
+ *    computed 0.02175 0.02292 0.00113
+ *      manual 0.00110 0.00123 0.00008
+ */
+/**
+ * @public
+ *
+ * Create a new record.
+ */
+function create(dataID) {
+  // See perf note above for why we aren't using computed property access.
+  var record = {};
+  record[ID_KEY] = dataID;
+  return record;
+}
+/**
+ * @public
+ *
+ * Get a scalar (non-link) field value.
+ */
+function getValue(record, storageKey) {
+  return record[storageKey];
+}
+/**
+ * @private
+ *
+ * Get the value of a field as a reference to another record. Throws if the
+ * field has a different type.
+ */
+function getLinkedRecordKey(record, storageKey, key) {
+  var link = record[storageKey];
+  if (link == null) {
+    return link;
+  }
+  return link[key];
+}
+/**
+ * @public
+ *
+ * Get the value of a field as a reference to another record. Throws if the
+ * field has a different type.
+ */
+function getLinkedRecordID(record, storageKey) {
+  return getLinkedRecordKey(record, storageKey, REF_KEY);
+}
+/**
+ * @public
+ *
+ * Get the value of a field as a list of references to other records. Throws if
+ * the field has a different type.
+ */
+function getLinkedRecordIDs(record, storageKey) {
+  return getLinkedRecordKey(record, storageKey, REFS_KEY);
+}
+/**
+ * @public
+ *
+ * Compares the fields of a previous and new record, returning either the
+ * previous record if all fields are equal or a new record (with merged fields)
+ * if any fields have changed.
+ */
+function update(prevRecord, nextRecord) {
+  var updated = null;
+  var keys = Object.keys(nextRecord);
+  for (var ii = 0; ii < keys.length; ii++) {
+    var key = keys[ii];
+    if (updated || !RelayStoreUtils_1.areEqual(prevRecord[key], nextRecord[key])) {
+      updated = updated !== null ? updated : __assign({}, prevRecord);
+      updated[key] = nextRecord[key];
+    }
+  }
+  return updated !== null ? updated : prevRecord;
+}
+/**
+ * @public
+ *
+ * Set the value of a storageKey to a scalar.
+ * YES
+ */
+function setValue(record, storageKey, value) {
+  record[storageKey] = value;
+}
+/**
+ * @private
+ *
+ * Get the value of a field as a reference to another record. Throws if the
+ * field has a different type.
+ */
+function setLinkedRecordKey(record, storageKey, linkedID, key) {
+  // See perf note above for why we aren't using computed property access.
+  var link = {};
+  link[key] = linkedID;
+  record[storageKey] = link;
+}
+/**
+ * @public
+ *
+ * Set the value of a field to a reference to another record.
+ */
+function setLinkedRecordID(record, storageKey, linkedID) {
+  setLinkedRecordKey(record, storageKey, linkedID, REF_KEY);
+}
+/**
+ * @public
+ *
+ * Set the value of a field to a list of references other records.
+ */
+function setLinkedRecordIDs(record, storageKey, linkedIDs) {
+  setLinkedRecordKey(record, storageKey, linkedIDs, REFS_KEY);
+}
+exports.RelayModernRecord = {
+  create: create,
+  getLinkedRecordID: getLinkedRecordID,
+  getLinkedRecordIDs: getLinkedRecordIDs,
+  getValue: getValue,
+  setValue: setValue,
+  setLinkedRecordID: setLinkedRecordID,
+  setLinkedRecordIDs: setLinkedRecordIDs,
+  update: update
+};

package/lib/relay/RelayModernSelector.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+export declare function getSingularSelector(fragment: any, item: any): any;
+export declare function createOperationDescriptor(request: any): any;

package/lib/relay/RelayModernSelector.js

@@ -0,0 +1,36 @@
+"use strict";
+
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+// flowlint ambiguous-object-type:error
+var RelayStoreUtils_1 = require("./RelayStoreUtils");
+var ID_KEY = RelayStoreUtils_1.RelayStoreUtils.ID_KEY;
+function createReaderSelector(node, dataID) {
+  return {
+    //kind: 'SingularReaderSelector',
+    dataID: dataID,
+    node: node
+  };
+}
+function getSingularSelector(fragment, item) {
+  return createReaderSelector(fragment, item[ID_KEY]);
+}
+exports.getSingularSelector = getSingularSelector;
+function createOperationDescriptor(request) {
+  var operationDescriptor = {
+    fragment: createReaderSelector(request.fragment, RelayStoreUtils_1.RelayStoreUtils.ROOT_ID),
+    identifier: request.identifier
+  };
+  return operationDescriptor;
+}
+exports.createOperationDescriptor = createOperationDescriptor;

package/lib/relay/RelayModernStore.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+import { MutableRecordSource, Store } from './RelayTypes';
+export declare function createStore(): RelayModernStore;
+/**
+ * @public
+ *
+ * An implementation of the `Store` interface defined in `RelayStoreTypes`.
+ *
+ * Note that a Store takes ownership of all records provided to it: other
+ * objects may continue to hold a reference to such records but may not mutate
+ * them. The static Relay core is architected to avoid mutating records that may have been
+ * passed to a store: operations that mutate records will either create fresh
+ * records or clone existing records and modify the clones. Record immutability
+ * is also enforced in development mode by freezing all records passed to a store.
+ */
+export declare class RelayModernStore implements Store {
+    _gcRun: any;
+    _recordSource: MutableRecordSource;
+    _roots: any;
+    _updatedRecordIDs: any;
+    _currentWriteEpoch: any;
+    _subs: any;
+    constructor(source: MutableRecordSource);
+    getSource(): MutableRecordSource;
+    commitUpdate(updater: any): void;
+    retain(operation: any): {
+        dispose: () => void;
+    };
+    lookup(selector: any): {
+        data: any;
+        seenRecords: any;
+        selector: any;
+    };
+    notify(): void;
+    _updateSub(source: any, subscription: any, updatedRecordIDs: any, hasUpdatedRecords: boolean): void;
+    publish(source: any): void;
+    subscribe(snapshot: any, callback: (snapshot: any) => void): {
+        dispose: () => void;
+    };
+    scheduleGC(): void;
+    _gcStep: () => void;
+    _collect(): Generator<void, void, void>;
+}