@inertiajs/svelte 2.3.17 → 3.0.0-beta.2

package/dist/useForm.js

@@ -1,356 +0,0 @@
-import { router, UseFormUtils } from '@inertiajs/core';
-import { createValidator, resolveName, toSimpleValidationErrors } from 'laravel-precognition';
-import { cloneDeep, get, has, isEqual, set } from 'lodash-es';
-import { get as getStore, writable } from 'svelte/store';
-import { config } from '.';
-let reservedFormKeys = null;
-let bootstrapping = false;
-function validateFormDataKeys(data) {
-    if (bootstrapping) {
-        return;
-    }
-    if (reservedFormKeys === null) {
-        bootstrapping = true;
-        const store = useForm({});
-        reservedFormKeys = new Set(Object.keys(getStore(store)));
-        bootstrapping = false;
-    }
-    const conflicts = Object.keys(data).filter((key) => reservedFormKeys.has(key));
-    if (conflicts.length > 0) {
-        console.error(`[Inertia] useForm() data contains field(s) that conflict with form properties: ${conflicts.map((k) => `"${k}"`).join(', ')}. ` +
-            `These fields will be overwritten by form methods/properties. Please rename these fields.`);
-    }
-}
-export default function useForm(...args) {
-    const parsedArgs = UseFormUtils.parseUseFormArguments(...args);
-    const { rememberKey, data: initialData } = parsedArgs;
-    let precognitionEndpoint = parsedArgs.precognitionEndpoint;
-    const data = typeof initialData === 'function' ? initialData() : initialData;
-    const restored = rememberKey
-        ? router.restore(rememberKey)
-        : null;
-    let defaults = cloneDeep(data);
-    validateFormDataKeys(defaults);
-    let cancelToken = null;
-    let recentlySuccessfulTimeoutId = null;
-    let transform = (data) => data;
-    let rememberExcludeKeys = [];
-    let defaultsCalledInOnSuccess = false;
-    let validatorRef = null;
-    let setFormState;
-    const withPrecognition = (...args) => {
-        precognitionEndpoint = UseFormUtils.createWayfinderCallback(...args);
-        const formWithPrecognition = () => getStore(store);
-        let withAllErrors = null;
-        if (!validatorRef) {
-            const validator = createValidator((client) => {
-                const { method, url } = precognitionEndpoint();
-                const form = formWithPrecognition();
-                const transformedData = cloneDeep(transform(form.data()));
-                return client[method](url, transformedData);
-            }, cloneDeep(defaults));
-            validatorRef = validator;
-            validator
-                .on('validatingChanged', () => {
-                setFormState('validating', validator.validating());
-            })
-                .on('validatedChanged', () => {
-                setFormState('__valid', validator.valid());
-            })
-                .on('touchedChanged', () => {
-                setFormState('__touched', validator.touched());
-            })
-                .on('errorsChanged', () => {
-                const validationErrors = (withAllErrors ?? config.get('form.withAllErrors'))
-                    ? validator.errors()
-                    : toSimpleValidationErrors(validator.errors());
-                setFormState('errors', {});
-                formWithPrecognition().setError(validationErrors);
-                setFormState('__valid', validator.valid());
-            });
-        }
-        const tap = (value, callback) => {
-            callback(value);
-            return value;
-        };
-        if (validatorRef) {
-            Object.assign(store, {});
-        }
-        store.update((form) => {
-            return Object.assign(store, {
-                ...form,
-                __touched: [],
-                __valid: [],
-                validating: false,
-                validator: () => validatorRef,
-                validate: (field, config) => {
-                    const form = formWithPrecognition();
-                    if (typeof field === 'object' && !('target' in field)) {
-                        config = field;
-                        field = undefined;
-                    }
-                    if (field === undefined) {
-                        validatorRef.validate(config);
-                    }
-                    else {
-                        field = resolveName(field);
-                        const transformedData = transform(form.data());
-                        validatorRef.validate(field, get(transformedData, field), config);
-                    }
-                    return form;
-                },
-                touch: (field, ...fields) => {
-                    const form = formWithPrecognition();
-                    if (Array.isArray(field)) {
-                        validatorRef?.touch(field);
-                    }
-                    else if (typeof field === 'string') {
-                        validatorRef?.touch([field, ...fields]);
-                    }
-                    else {
-                        validatorRef?.touch(field);
-                    }
-                    return form;
-                },
-                validateFiles: () => tap(formWithPrecognition(), () => validatorRef?.validateFiles()),
-                setValidationTimeout: (duration) => tap(formWithPrecognition(), () => validatorRef.setTimeout(duration)),
-                withAllErrors: () => tap(formWithPrecognition(), () => (withAllErrors = true)),
-                withoutFileValidation: () => tap(formWithPrecognition(), () => validatorRef?.withoutFileValidation()),
-                valid: (field) => formWithPrecognition().__valid.includes(field),
-                invalid: (field) => field in formWithPrecognition().errors,
-                touched: (field) => {
-                    const touched = formWithPrecognition().__touched;
-                    return typeof field === 'string' ? touched.includes(field) : touched.length > 0;
-                },
-                setErrors: (errors) => tap(formWithPrecognition(), () => {
-                    const form = formWithPrecognition();
-                    form.setError(errors);
-                }),
-                forgetError: (field) => tap(formWithPrecognition(), () => {
-                    const form = formWithPrecognition();
-                    form.clearErrors(resolveName(field));
-                }),
-            });
-        });
-        return store;
-    };
-    const store = writable({
-        ...(restored ? restored.data : data),
-        isDirty: false,
-        errors: (restored ? restored.errors : {}),
-        hasErrors: false,
-        progress: null,
-        wasSuccessful: false,
-        recentlySuccessful: false,
-        processing: false,
-        setStore(keyOrData, maybeValue = undefined) {
-            store.update((store) => {
-                return typeof keyOrData === 'string' ? set(store, keyOrData, maybeValue) : Object.assign(store, keyOrData);
-            });
-        },
-        data() {
-            return Object.keys(data).reduce((carry, key) => {
-                return set(carry, key, get(this, key));
-            }, {});
-        },
-        transform(callback) {
-            transform = callback;
-            return this;
-        },
-        defaults(fieldOrFields, maybeValue) {
-            defaultsCalledInOnSuccess = true;
-            if (typeof fieldOrFields === 'undefined') {
-                defaults = cloneDeep(this.data());
-            }
-            else {
-                defaults =
-                    typeof fieldOrFields === 'string'
-                        ? set(cloneDeep(defaults), fieldOrFields, maybeValue)
-                        : Object.assign(cloneDeep(defaults), fieldOrFields);
-            }
-            validatorRef?.defaults(defaults);
-            return this;
-        },
-        reset(...fields) {
-            const clonedData = cloneDeep(defaults);
-            if (fields.length === 0) {
-                this.setStore(clonedData);
-            }
-            else {
-                this.setStore(fields
-                    .filter((key) => has(clonedData, key))
-                    .reduce((carry, key) => {
-                    return set(carry, key, get(clonedData, key));
-                }, {}));
-            }
-            validatorRef?.reset(...fields);
-            return this;
-        },
-        setError(fieldOrFields, maybeValue) {
-            const errors = typeof fieldOrFields === 'string' ? { [fieldOrFields]: maybeValue } : fieldOrFields;
-            setFormState('errors', {
-                ...this.errors,
-                ...errors,
-            });
-            validatorRef?.setErrors(errors);
-            return this;
-        },
-        clearErrors(...fields) {
-            setFormState('errors', Object.keys(this.errors).reduce((carry, field) => ({
-                ...carry,
-                ...(fields.length > 0 && !fields.includes(field) ? { [field]: this.errors[field] } : {}),
-            }), {}));
-            if (validatorRef) {
-                if (fields.length === 0) {
-                    validatorRef.setErrors({});
-                }
-                else {
-                    fields.forEach(validatorRef.forgetError);
-                }
-            }
-            return this;
-        },
-        resetAndClearErrors(...fields) {
-            this.reset(...fields);
-            this.clearErrors(...fields);
-            return this;
-        },
-        submit(...args) {
-            const { method, url, options } = UseFormUtils.parseSubmitArguments(args, precognitionEndpoint);
-            defaultsCalledInOnSuccess = false;
-            const data = transform(this.data());
-            const _options = {
-                ...options,
-                onCancelToken: (token) => {
-                    cancelToken = token;
-                    if (options.onCancelToken) {
-                        return options.onCancelToken(token);
-                    }
-                },
-                onBefore: (visit) => {
-                    setFormState('wasSuccessful', false);
-                    setFormState('recentlySuccessful', false);
-                    if (recentlySuccessfulTimeoutId) {
-                        clearTimeout(recentlySuccessfulTimeoutId);
-                    }
-                    if (options.onBefore) {
-                        return options.onBefore(visit);
-                    }
-                },
-                onStart: (visit) => {
-                    setFormState('processing', true);
-                    if (options.onStart) {
-                        return options.onStart(visit);
-                    }
-                },
-                onProgress: (event) => {
-                    setFormState('progress', event || null);
-                    if (options.onProgress) {
-                        return options.onProgress(event);
-                    }
-                },
-                onSuccess: async (page) => {
-                    setFormState('processing', false);
-                    setFormState('progress', null);
-                    this.clearErrors();
-                    setFormState('wasSuccessful', true);
-                    setFormState('recentlySuccessful', true);
-                    recentlySuccessfulTimeoutId = setTimeout(() => setFormState('recentlySuccessful', false), config.get('form.recentlySuccessfulDuration'));
-                    const onSuccess = options.onSuccess ? await options.onSuccess(page) : null;
-                    if (!defaultsCalledInOnSuccess) {
-                        this.defaults(cloneDeep(getStore(store).data()));
-                    }
-                    return onSuccess;
-                },
-                onError: (errors) => {
-                    setFormState('processing', false);
-                    setFormState('progress', null);
-                    setFormState('errors', errors);
-                    validatorRef?.setErrors(errors);
-                    if (options.onError) {
-                        return options.onError(errors);
-                    }
-                },
-                onCancel: () => {
-                    setFormState('processing', false);
-                    setFormState('progress', null);
-                    if (options.onCancel) {
-                        return options.onCancel();
-                    }
-                },
-                onFinish: (visit) => {
-                    setFormState('processing', false);
-                    setFormState('progress', null);
-                    cancelToken = null;
-                    if (options.onFinish) {
-                        return options.onFinish(visit);
-                    }
-                },
-            };
-            if (method === 'delete') {
-                router.delete(url, { ..._options, data });
-            }
-            else {
-                router[method](url, data, _options);
-            }
-        },
-        get(url, options) {
-            this.submit('get', url, options);
-        },
-        post(url, options) {
-            this.submit('post', url, options);
-        },
-        put(url, options) {
-            this.submit('put', url, options);
-        },
-        patch(url, options) {
-            this.submit('patch', url, options);
-        },
-        delete(url, options) {
-            this.submit('delete', url, options);
-        },
-        cancel() {
-            cancelToken?.cancel();
-        },
-        __remember() {
-            const data = this.data();
-            if (rememberExcludeKeys.length > 0) {
-                const filtered = { ...data };
-                rememberExcludeKeys.forEach((k) => delete filtered[k]);
-                return { data: filtered, errors: this.errors };
-            }
-            return { data, errors: this.errors };
-        },
-        withPrecognition,
-    });
-    const dontRememberMethod = (...keys) => {
-        rememberExcludeKeys = keys;
-        return store;
-    };
-    Object.assign(store, {
-        withPrecognition,
-        dontRemember: dontRememberMethod,
-    });
-    setFormState = (key, value) => {
-        store.update((form) => ({ ...form, [key]: value }));
-    };
-    store.subscribe((form) => {
-        if (form.isDirty === isEqual(form.data(), defaults)) {
-            setFormState('isDirty', !form.isDirty);
-        }
-        const hasErrors = Object.keys(form.errors).length > 0;
-        if (form.hasErrors !== hasErrors) {
-            setFormState('hasErrors', !form.hasErrors);
-        }
-        if (rememberKey) {
-            const storedData = router.restore(rememberKey);
-            const newData = form.__remember();
-            if (!isEqual(storedData, newData)) {
-                router.remember(newData, rememberKey);
-            }
-        }
-    });
-    return precognitionEndpoint
-        ? store.withPrecognition(precognitionEndpoint)
-        : store;
-}

package/dist/usePrefetch.d.ts

@@ -1,7 +0,0 @@
-import { type VisitOptions } from '@inertiajs/core';
-export default function usePrefetch(options?: VisitOptions): {
-    isPrefetched: import("svelte/store").Readable<boolean>;
-    isPrefetching: import("svelte/store").Readable<boolean>;
-    lastUpdatedAt: import("svelte/store").Readable<number | null>;
-    flush(): void;
-};

package/dist/useRemember.d.ts

@@ -1 +0,0 @@
-export default function useRemember<State>(initialState: State, key?: string): import("svelte/store").Writable<State>;

package/dist/useRemember.js

@@ -1,11 +0,0 @@
-import { router } from '@inertiajs/core';
-import { cloneDeep } from 'lodash-es';
-import { onDestroy } from 'svelte';
-import { writable } from 'svelte/store';
-export default function useRemember(initialState, key) {
-    const restored = router.restore(key);
-    const store = writable(restored !== undefined ? cloneDeep(restored) : initialState);
-    const unsubscribe = store.subscribe((state) => router.remember(cloneDeep(state), key));
-    onDestroy(unsubscribe);
-    return store;
-}