eddev 0.2.67-beta1 → 0.3.0-beta1

package/gravityforms/useGravityForm.js

@@ -1,70 +1,77 @@
 "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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useGravityForm = void 0;
-const react_1 = require("react");
-const react_2 = require("react");
-const react_3 = require("react");
-const reducer = (state, action) => {
+var react_1 = require("react");
+var react_2 = require("react");
+var react_3 = require("react");
+var reducer = function (state, action) {
+    var _a, _b, _c;
     switch (action.type) {
         case "field":
-            return {
-                ...state,
-                errors: {
-                    ...state.errors,
-                    [action.id]: undefined,
-                },
-                values: {
-                    ...state.values,
-                    [action.id]: action.value,
-                },
-            };
+            return __assign(__assign({}, state), { errors: __assign(__assign({}, state.errors), (_a = {}, _a[action.id] = undefined, _a)), values: __assign(__assign({}, state.values), (_b = {}, _b[action.id] = action.value, _b)) });
         case "submitting":
-            return {
-                ...state,
-                errors: {},
-                validity: {},
-                hasErrors: false,
-                submitting: true,
-            };
+            return __assign(__assign({}, state), { errors: {}, validity: {}, hasErrors: false, submitting: true });
         case "success":
-            return {
-                ...state,
-                submitting: false,
-                complete: true,
-                errors: {},
-                validity: {},
-                hasErrors: false,
-                successMessage: action.message,
-            };
+            return __assign(__assign({}, state), { submitting: false, complete: true, errors: {}, validity: {}, hasErrors: false, successMessage: action.message });
         case "mainError":
-            return {
-                ...state,
-                submitting: false,
-                hasErrors: true,
-                mainError: action.message,
-            };
+            return __assign(__assign({}, state), { submitting: false, hasErrors: true, mainError: action.message });
         case "errors":
-            return {
-                ...state,
-                submitting: false,
-                hasErrors: true,
-                errors: action.errors,
-            };
+            return __assign(__assign({}, state), { submitting: false, hasErrors: true, errors: action.errors });
         case "clearError":
-            return {
-                ...state,
-                submitting: false,
-                errors: {
-                    ...state.errors,
-                    [action.id]: undefined,
-                },
-            };
+            return __assign(__assign({}, state), { submitting: false, errors: __assign(__assign({}, state.errors), (_c = {}, _c[action.id] = undefined, _c)) });
         default:
-            throw new Error(`Unknown GravityForms action ${JSON.stringify(action)}`);
+            throw new Error("Unknown GravityForms action ".concat(JSON.stringify(action)));
     }
     return state;
 };
-const initializer = (form) => {
+var initializer = function (form) {
     return {
         submitting: false,
         mainError: null,
@@ -77,23 +84,18 @@ const initializer = (form) => {
     };
 };
 function useGravityForm(opts) {
-    const { form } = opts;
-    const [state, dispatch] = (0, react_3.useReducer)(reducer, form, initializer);
-    const fields = form.fields.map((field) => ({
-        ...field,
-        value: state.values[field.id],
-        error: state.errors[field.id],
-        set: (value) => {
-            dispatch({ type: "field", id: field.id, value });
-        },
-    }));
-    const [submitter, setSubmitter] = (0, react_2.useState)(null);
-    (0, react_1.useEffect)(() => {
-        let cancelled = false;
+    var form = opts.form;
+    var _a = (0, react_3.useReducer)(reducer, form, initializer), state = _a[0], dispatch = _a[1];
+    var fields = form.fields.map(function (field) { return (__assign(__assign({}, field), { value: state.values[field.id], error: state.errors[field.id], set: function (value) {
+            dispatch({ type: "field", id: field.id, value: value });
+        } })); });
+    var _b = (0, react_2.useState)(null), submitter = _b[0], setSubmitter = _b[1];
+    (0, react_1.useEffect)(function () {
+        var cancelled = false;
         setSubmitter({
-            submit: (state) => {
+            submit: function (state) {
                 dispatch({ type: "submitting" });
-                submit(form, state).then((result) => {
+                submit(form, state).then(function (result) {
                     if (cancelled)
                         return;
                     if (result.success) {
@@ -108,32 +110,27 @@ function useGravityForm(opts) {
                 });
             },
         });
-        return () => {
+        return function () {
             cancelled = true;
         };
     }, []);
-    return {
-        ...state,
-        fields,
-        submit() {
-            submitter?.submit(state);
-        },
-        updateField(id, value) {
-            dispatch({ type: "field", id, value });
-        },
-    };
+    return __assign(__assign({}, state), { fields: fields, submit: function () {
+            submitter === null || submitter === void 0 ? void 0 : submitter.submit(state);
+        }, updateField: function (id, value) {
+            dispatch({ type: "field", id: id, value: value });
+        } });
 }
 exports.useGravityForm = useGravityForm;
 function prepareValuesPayload(form, state, data) {
-    for (const field of form.fields) {
-        const value = state.values[field.id];
-        let key = "input_" + field.id;
+    var _loop_1 = function (field) {
+        var value = state.values[field.id];
+        var key = "input_" + field.id;
         if (field.type === "consent") {
             key += "_1";
         }
         if (field.type === "checkbox") {
-            field.choices.forEach((choice, i) => {
-                data.append(`${key}.${i + 1}`, value?.includes(choice.value) ? choice.value : "");
+            field.choices.forEach(function (choice, i) {
+                data.append("".concat(key, ".").concat(i + 1), (value === null || value === void 0 ? void 0 : value.includes(choice.value)) ? choice.value : "");
                 // data[`${key}.${i + 1}`] =
             });
         }
@@ -147,50 +144,57 @@ function prepareValuesPayload(form, state, data) {
             }
             // data[key] = value
         }
+    };
+    for (var _i = 0, _a = form.fields; _i < _a.length; _i++) {
+        var field = _a[_i];
+        _loop_1(field);
     }
     // return data
 }
-async function submit(form, state) {
-    try {
-        let url = process.serverless ? `/api/rest/form-submit` : `/wp-json/ed/v1/gf/submit-with-uploads`;
-        const data = new FormData();
-        data.append("formID", String(form.id));
-        prepareValuesPayload(form, state, data);
-        const result = await fetch(url, {
-            method: "POST",
-            headers: {
-            // "Content-type": "application/json",
-            },
-            credentials: "include",
-            body: data,
+function submit(form, state) {
+    return __awaiter(this, void 0, void 0, function () {
+        var url, data, result, payload, err_1;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    _a.trys.push([0, 3, , 4]);
+                    url = process.serverless ? "/api/rest/form-submit" : "/wp-json/ed/v1/gf/submit-with-uploads";
+                    data = new FormData();
+                    data.append("formID", String(form.id));
+                    prepareValuesPayload(form, state, data);
+                    return [4 /*yield*/, fetch(url, {
+                            method: "POST",
+                            headers: {
+                            // "Content-type": "application/json",
+                            },
+                            credentials: "include",
+                            body: data,
+                        })];
+                case 1:
+                    result = _a.sent();
+                    return [4 /*yield*/, result.json()];
+                case 2:
+                    payload = _a.sent();
+                    if (!payload.is_valid) {
+                        return [2 /*return*/, __assign(__assign({}, payload), { success: false, errors: payload.validation_messages })];
+                    }
+                    else if (payload.is_valid) {
+                        return [2 /*return*/, __assign(__assign({}, payload), { success: true, successMessage: payload.confirmation_message })];
+                    }
+                    else {
+                        console.error("Not sure what to do with GF response", payload);
+                        return [2 /*return*/, __assign({}, payload)];
+                    }
+                    return [3 /*break*/, 4];
+                case 3:
+                    err_1 = _a.sent();
+                    console.error(err_1);
+                    return [2 /*return*/, {
+                            success: false,
+                            mainError: "An error occurred while submitting this form. Please contact us directly if the issue persists.",
+                        }];
+                case 4: return [2 /*return*/];
+            }
         });
-        const payload = await result.json();
-        if (!payload.is_valid) {
-            return {
-                ...payload,
-                success: false,
-                errors: payload.validation_messages,
-            };
-        }
-        else if (payload.is_valid) {
-            return {
-                ...payload,
-                success: true,
-                successMessage: payload.confirmation_message,
-            };
-        }
-        else {
-            console.error("Not sure what to do with GF response", payload);
-            return {
-                ...payload,
-            };
-        }
-    }
-    catch (err) {
-        console.error(err);
-        return {
-            success: false,
-            mainError: "An error occurred while submitting this form. Please contact us directly if the issue persists.",
-        };
-    }
+    });
 }

package/hooks/index.js

@@ -1,11 +1,7 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
+    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];

package/hooks/queryUtils.d.ts

@@ -1,31 +1,31 @@
 /** Generic Error */
-type GraphQLError = {
+declare type GraphQLError = {
     message: string;
 };
 /** Regular queries */
-type CreateUseQueryOptions = {
+declare type CreateUseQueryOptions = {
     name: string;
 };
-type QueryOptions = {
+declare type QueryOptions = {
     revalidateIfStale?: boolean;
     revalidateOnFocus?: boolean;
 };
-type MaybeVars = {
+declare type MaybeVars = {
     [key: string]: any;
 } | undefined;
-type QueryHookReturn<TReturn, TVars> = {
+declare type QueryHookReturn<TReturn, TVars> = {
     loading: boolean;
     errors?: GraphQLError[];
     data?: TReturn;
     refresh: (vars?: TVars) => void;
 };
-type QueryHook<TReturn, TVars> = TVars extends undefined ? (vars?: TVars, opts?: QueryOptions) => QueryHookReturn<TReturn, TVars> : (vars: TVars, opts?: QueryOptions) => QueryHookReturn<TReturn, TVars>;
-type QueryFetcher<TReturn, TVars> = {
+declare type QueryHook<TReturn, TVars> = TVars extends undefined ? (vars?: TVars, opts?: QueryOptions) => QueryHookReturn<TReturn, TVars> : (vars: TVars, opts?: QueryOptions) => QueryHookReturn<TReturn, TVars>;
+declare type QueryFetcher<TReturn, TVars> = {
     fetch: TVars extends undefined ? (vars?: TVars) => Promise<TReturn> : (vars: TVars) => Promise<TReturn>;
 };
 export declare function createUseQuery<TReturn extends any, TVars extends MaybeVars>(init: CreateUseQueryOptions): QueryHook<TReturn, TVars> & QueryFetcher<TReturn, TVars>;
 /** Infinite queries */
-type CreateUseInfiniteQueryOptions = {
+declare type CreateUseInfiniteQueryOptions = {
     name: string;
     defaultLimit: number;
     paths: {
@@ -35,7 +35,7 @@ type CreateUseInfiniteQueryOptions = {
         hasNextPagePath: string[];
     };
 };
-type InfiniteQueryHookReturn<TItem, TVars> = {
+declare type InfiniteQueryHookReturn<TItem, TVars> = {
     loading: boolean;
     loadingMore: boolean;
     errors?: GraphQLError[];
@@ -45,18 +45,18 @@ type InfiniteQueryHookReturn<TItem, TVars> = {
     refresh: () => void;
     loadMore: () => void;
 };
-type InfiniteQueryHasAdditionalVars<TVars> = Exclude<keyof TVars, "limit" | "cursor"> extends never ? false : true;
-type InfiniteQueryHook<TItem, TVars> = InfiniteQueryHasAdditionalVars<TVars> extends false ? (vars?: TVars, opts?: QueryOptions) => InfiniteQueryHookReturn<TItem, TVars> : (vars: TVars, opts?: QueryOptions) => InfiniteQueryHookReturn<TItem, TVars>;
+declare type InfiniteQueryHasAdditionalVars<TVars> = Exclude<keyof TVars, "limit" | "cursor"> extends never ? false : true;
+declare type InfiniteQueryHook<TItem, TVars> = InfiniteQueryHasAdditionalVars<TVars> extends false ? (vars?: TVars, opts?: QueryOptions) => InfiniteQueryHookReturn<TItem, TVars> : (vars: TVars, opts?: QueryOptions) => InfiniteQueryHookReturn<TItem, TVars>;
 export declare function createUseInfiniteQuery<TItem, TVars extends MaybeVars>(init: CreateUseInfiniteQueryOptions): InfiniteQueryHook<TItem, TVars>;
-type MutationHookReturn<TReturn, TVars> = {
+declare type MutationHookReturn<TReturn, TVars> = {
     submitting: boolean;
     submitted: boolean;
     errors?: GraphQLError[];
     data?: TReturn;
     submit: (vars: TVars) => void;
 };
-type MutationHook<TReturn, TVars> = (opts?: QueryOptions) => MutationHookReturn<TReturn, TVars>;
-type MutationFetcher<TReturn, TVars> = {
+declare type MutationHook<TReturn, TVars> = (opts?: QueryOptions) => MutationHookReturn<TReturn, TVars>;
+declare type MutationFetcher<TReturn, TVars> = {
     mutate: (vars: TVars) => Promise<TReturn>;
 };
 export declare function createUseMutation<TReturn extends any, TVars extends MaybeVars>(init: CreateUseQueryOptions): MutationHook<TReturn, TVars> & MutationFetcher<TReturn, TVars>;