mobx-formly 0.0.2 → 0.1.0

package/dist/form.js

@@ -0,0 +1,612 @@
+import { action, computed, makeObservable, observable, runInAction } from 'mobx';
+import { createRef } from 'yummies/mobx';
+import { clone, deleteAtPath, extractValue, getAtPath, isEqual, setAtPath } from './utils.js';
+import { collectChangedPaths, collectDirtyPaths, collectErrorPaths, findErrorAtPath } from './utils.js';
+import { PathStore } from './path-store.js';
+import { FormValidator } from './validation.js';
+const isPromiseLike = (value) => !!value && typeof value.then === 'function';
+export class BaseForm {
+    /**
+     * Current form values.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#values)
+     */
+    values;
+    /**
+     * Cached default values used by reset, resetField, and dirty comparison.
+     * Updated by reset unless `keepDefaultValues` is passed.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#defaultvalues)
+     */
+    defaultValues;
+    errorStore = new PathStore();
+    fieldStateStore = new PathStore();
+    /** Validation errors nested by field path. */
+    get errors() {
+        return this.errorStore.proxy();
+    }
+    /**
+     * Field paths whose values differ from their defaults.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#dirtyfields)
+     */
+    dirtyFields = {};
+    /**
+     * Field paths that have been touched.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#touchedfields)
+     */
+    touchedFields = {};
+    /**
+     * Field paths that are currently being validated.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#validatingfields)
+     */
+    validatingFields = {};
+    /**
+     * Observable state for each registered field, nested by field path.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#fieldstate)
+     */
+    get fieldState() {
+        return this.fieldStateStore.proxy();
+    }
+    /**
+     * Whether a submission is currently running.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#issubmitting)
+     */
+    isSubmitting = false;
+    /**
+     * Whether the form has been submitted at least once.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#issubmitted)
+     */
+    isSubmitted = false;
+    /**
+     * Whether the latest submission succeeded.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#issubmitsuccessful)
+     */
+    isSubmitSuccessful = false;
+    /**
+     * Number of submission attempts.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#submitcount)
+     */
+    submitCount = 0;
+    /**
+     * Refs registered for fields.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#refs)
+     */
+    refs = new Map();
+    options;
+    fieldOptions = new Map();
+    touchedValidationFields = new Set();
+    validator;
+    activeSubmissions = 0;
+    resetVersion = 0;
+    isValidOverride = observable.box(undefined);
+    validationVersion = 0;
+    fieldValidationVersions = new Map();
+    /** Whether at least one validation pass has completed since construction or reset. */
+    hasValidationRun = false;
+    constructor(options = {}) {
+        this.options = {
+            ...options,
+            mode: options.mode ?? 'onSubmit',
+            reValidateMode: options.reValidateMode ?? 'onChange',
+            disabled: options.disabled ?? false,
+            shouldFocusError: options.shouldFocusError ?? true,
+        };
+        this.defaultValues = clone((options.defaultValues ?? {}));
+        this.values = clone((options.values ?? options.defaultValues ?? {}));
+        this.validator = new FormValidator({
+            options: this.options,
+            fieldOptions: this.fieldOptions,
+            refs: this.refs,
+            valueAt: (path) => getAtPath(this.values, path),
+            snapshot: () => this.snapshot,
+            applyError: (path, error) => this.applyError(path, error),
+        });
+        makeObservable(this, {
+            values: observable.deep,
+            defaultValues: observable.deep,
+            dirtyFields: observable.shallow,
+            touchedFields: observable.shallow,
+            validatingFields: observable.shallow,
+            isSubmitting: observable,
+            isSubmitted: observable,
+            isSubmitSuccessful: observable,
+            submitCount: observable,
+            disabled: computed,
+            isDirty: computed,
+            isTouched: computed,
+            isValidating: computed,
+            isValid: computed,
+            snapshot: computed,
+            register: action,
+            unregister: action,
+            setValue: action,
+            mutate: action,
+            setError: action,
+            clearErrors: action,
+            trigger: action,
+            handleSubmit: action,
+            reset: action,
+            resetField: action,
+            setFocus: action,
+        });
+    }
+    /**
+     * Whether registered event handlers ignore changes and blur events.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#disabled)
+     */
+    get disabled() { return this.options.disabled; }
+    /**
+     * Whether any field is dirty.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#isdirty)
+     */
+    get isDirty() { return Object.keys(this.dirtyFields).length > 0; }
+    /**
+     * Whether any field has been touched.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#istouched)
+     */
+    get isTouched() { return Object.keys(this.touchedFields).length > 0; }
+    /** Whether any field validation is currently running. */
+    get isValidating() { return Object.keys(this.validatingFields).length > 0; }
+    /**
+     * Whether the form has no errors. With a schema or resolver the first read
+     * schedules a full validation pass, so validity reflects the schema instead
+     * of defaulting to true until something validates.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#isvalid)
+     */
+    get isValid() {
+        const override = this.isValidOverride.get();
+        if (override !== undefined)
+            return override;
+        if (!this.hasValidationRun && (this.options.schema || this.options.resolver)) {
+            this.hasValidationRun = true;
+            // Deferred so this computed getter stays free of observable side effects.
+            queueMicrotask(() => { void this.runValidation(); });
+        }
+        return this.errorStore.size === 0;
+    }
+    /**
+     * Registers a field and returns its ref and event handlers.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#registername-options)
+     */
+    register(name, options = {}) {
+        const path = name;
+        this.fieldOptions.set(path, options);
+        const ref = this.ref(name);
+        this.ensureFieldState(path);
+        return {
+            name: path,
+            ref,
+            onChange: async (eventOrValue) => {
+                if (this.disabled)
+                    return;
+                const value = this.transformValue(extractValue(eventOrValue), options);
+                const shouldValidate = this.shouldValidateOnChange(path);
+                const deps = this.dependentFields(options.deps);
+                this.setValue(path, value, { shouldDirty: true, shouldValidate: false });
+                if (shouldValidate && deps.length) {
+                    await Promise.all([this.trigger(path), this.trigger(deps)]);
+                }
+                else if (shouldValidate) {
+                    await this.trigger(path);
+                }
+                else if (deps.length) {
+                    await this.trigger(deps);
+                }
+            },
+            onBlur: async () => {
+                if (this.disabled)
+                    return;
+                this.markTouched(path);
+                if (this.options.mode === 'onTouched')
+                    this.touchedValidationFields.add(path);
+                if (this.options.mode === 'onBlur' || this.options.mode === 'onTouched' || this.options.mode === 'all' || (this.hasError(path) && this.options.reValidateMode === 'onBlur')) {
+                    this.validator.flushDelayed(path);
+                    await this.trigger(path);
+                }
+            },
+        };
+    }
+    /**
+     * Returns the stable MobX-aware ref for a field path, creating it on demand.
+     * The ref can be used by a view adapter before the field is registered.
+     */
+    ref(name) {
+        const path = name;
+        let ref = this.refs.get(path);
+        if (!ref) {
+            ref = createRef();
+            this.refs.set(path, ref);
+        }
+        return ref;
+    }
+    /**
+     * Removes a field, its value, and its associated state.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#unregistername)
+     */
+    unregister(name) {
+        const path = name;
+        this.fieldValidationVersions.set(path, (this.fieldValidationVersions.get(path) ?? 0) + 1);
+        this.validator.cancelDelayed(path);
+        this.touchedValidationFields.delete(path);
+        deleteAtPath(this.values, path);
+        this.applyError(path, undefined);
+        delete this.dirtyFields[path];
+        delete this.touchedFields[path];
+        delete this.validatingFields[path];
+        this.fieldStateStore.delete(path);
+        this.fieldOptions.delete(path);
+        this.refs.delete(path);
+    }
+    /**
+     * Updates a field value and optionally changes its state or validates it.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#setvaluename-value-config)
+     */
+    setValue(name, value, config = {}) {
+        const path = name;
+        setAtPath(this.values, path, value);
+        this.applyValueChange(path, config);
+    }
+    mutate(mutator, config = {}) {
+        const before = clone(this.values);
+        const result = mutator();
+        if (isPromiseLike(result)) {
+            return result.then(() => runInAction(() => this.finishMutation(before, config)), (error) => {
+                runInAction(() => this.finishMutation(before, config));
+                throw error;
+            });
+        }
+        this.finishMutation(before, config);
+    }
+    finishMutation(before, config) {
+        if (isEqual(before, this.values))
+            return;
+        const changedPaths = collectChangedPaths(before, this.values);
+        const dirtyPaths = collectDirtyPaths(this.values, this.defaultValues);
+        if (config.shouldDirty ?? true)
+            this.syncDirtyFields(dirtyPaths);
+        if (config.shouldTouch ?? true)
+            for (const path of changedPaths)
+                this.markTouched(path);
+        if (config.shouldValidate ?? true)
+            void this.trigger();
+    }
+    applyValueChange(path, config) {
+        if (config.shouldDirty ?? true)
+            this.updateDirty(path);
+        if (config.shouldTouch ?? true)
+            this.markTouched(path);
+        if (config.shouldValidate)
+            void this.trigger(path);
+    }
+    /**
+     * Sets an error for a field and can focus it.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#seterrorname-error)
+     */
+    setError(name, error, config = {}) {
+        const path = name;
+        this.validator.cancelDelayed(path);
+        this.applyError(path, error);
+        if (config.shouldFocus)
+            this.refs.get(path)?.current?.focus();
+    }
+    /**
+     * Clears one, several, or all field errors.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#clearerrorsname)
+     */
+    clearErrors(name) {
+        if (!name) {
+            this.validator.cancelAllDelayed();
+            this.isValidOverride.set(undefined);
+            this.errorStore.clear();
+            for (const [, state] of this.fieldStateStore.entries())
+                this.applyFieldState(state, undefined);
+            return;
+        }
+        for (const path of Array.isArray(name) ? name : [name]) {
+            this.clearErrorPath(path);
+        }
+    }
+    /**
+     * Validates one field, several fields, or the complete form.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#triggername)
+     */
+    async trigger(name, config = {}) {
+        const paths = name ? (Array.isArray(name) ? name : [name]).map(String) : [...this.fieldOptions.keys()];
+        if (config.shouldTouch)
+            for (const path of paths)
+                this.markTouched(path);
+        const valid = (await this.runValidation(name)).valid;
+        if (!valid && config.shouldFocus)
+            this.focusFirstError(paths);
+        return valid;
+    }
+    async runValidation(name) {
+        this.hasValidationRun = true;
+        const paths = name ? (Array.isArray(name) ? name : [name]).map(String) : undefined;
+        const run = ++this.validationVersion;
+        const fieldVersions = new Map();
+        for (const path of paths ?? this.fieldOptions.keys()) {
+            if (this.fieldOptions.has(path))
+                fieldVersions.set(path, this.fieldValidationVersions.get(path) ?? 0);
+        }
+        for (const path of paths ?? this.fieldOptions.keys()) {
+            this.validatingFields[path] = true;
+            this.ensureFieldState(path).isValidating = true;
+        }
+        let valid = true;
+        try {
+            const schemaResult = await this.validator.resolveSchemaErrors(paths);
+            const schemaErrors = schemaResult.errors;
+            const validationPaths = paths ?? [...new Set([...this.fieldOptions.keys(), ...this.errorStore.paths(), ...collectErrorPaths(schemaErrors)])];
+            for (const path of validationPaths) {
+                const ruleError = await this.validator.validateRules(path);
+                runInAction(() => {
+                    if (this.isValidationCurrent(path, run, fieldVersions)) {
+                        const schemaError = findErrorAtPath(schemaErrors, path);
+                        const error = this.validator.mergeErrors(schemaError, ruleError);
+                        if (error)
+                            valid = false;
+                        this.validator.applyValidationError(path, error);
+                    }
+                });
+            }
+            return { valid, values: valid ? schemaResult.values : undefined };
+        }
+        finally {
+            runInAction(() => {
+                if (this.validationVersion === run) {
+                    for (const path of paths ?? this.fieldOptions.keys()) {
+                        if (!this.isValidationCurrent(path, run, fieldVersions))
+                            continue;
+                        delete this.validatingFields[path];
+                        this.ensureFieldState(path).isValidating = false;
+                    }
+                }
+            });
+        }
+    }
+    /**
+     * Creates an asynchronous submit handler with validation and result callbacks.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#handlesubmithandlers)
+     */
+    handleSubmit({ onValid, onInvalid }) {
+        return async () => {
+            this.activeSubmissions += 1;
+            this.isSubmitting = true;
+            this.isSubmitted = true;
+            this.submitCount += 1;
+            const submissionResetVersion = this.resetVersion;
+            try {
+                const { valid, values } = await this.runValidation();
+                if (valid) {
+                    await onValid(values ?? this.snapshot, this);
+                    runInAction(() => {
+                        if (this.resetVersion === submissionResetVersion)
+                            this.isSubmitSuccessful = true;
+                    });
+                }
+                else {
+                    if (this.options.shouldFocusError)
+                        this.focusFirstError();
+                    await onInvalid?.(this.errors, this);
+                    runInAction(() => {
+                        if (this.resetVersion === submissionResetVersion)
+                            this.isSubmitSuccessful = false;
+                    });
+                }
+            }
+            finally {
+                runInAction(() => {
+                    this.activeSubmissions -= 1;
+                    this.isSubmitting = this.activeSubmissions > 0;
+                });
+            }
+        };
+    }
+    /**
+     * Resets values and selected form state.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#resetvalues-options)
+     */
+    reset(values, options = {}) {
+        this.validator.cancelAllDelayed();
+        this.touchedValidationFields.clear();
+        this.resetVersion += 1;
+        this.validationVersion += 1;
+        if (!options.keepIsValidating) {
+            for (const path of Object.keys(this.validatingFields)) {
+                delete this.validatingFields[path];
+                const state = this.fieldStateStore.get(path);
+                if (state)
+                    state.isValidating = false;
+            }
+        }
+        if (!options.keepValues) {
+            const next = clone((values ?? this.defaultValues));
+            if (options.keepDirtyValues) {
+                for (const path of Object.keys(this.dirtyFields)) {
+                    const value = getAtPath(this.values, path);
+                    if (value !== undefined)
+                        setAtPath(next, path, clone(value));
+                }
+            }
+            this.values = next;
+            // New values need a fresh validity check on the next isValid read.
+            this.hasValidationRun = false;
+        }
+        if (!options.keepDefaultValues && values)
+            Object.assign(this.defaultValues, clone(values));
+        if (!options.keepDirty && !options.keepDirtyValues)
+            this.dirtyFields = {};
+        if (!options.keepTouched)
+            this.touchedFields = {};
+        // Raw validity without the lazy warm-up: reset must never schedule validation.
+        const wasValid = this.isValidOverride.get() ?? this.errorStore.size === 0;
+        if (!options.keepErrors) {
+            this.errorStore.clear();
+            for (const [, state] of this.fieldStateStore.entries())
+                this.applyFieldState(state, undefined);
+        }
+        this.isValidOverride.set(options.keepIsValid ? wasValid : undefined);
+        if (!options.keepIsSubmitted)
+            this.isSubmitted = false;
+        if (!options.keepIsSubmitSuccessful)
+            this.isSubmitSuccessful = false;
+        if (!options.keepSubmitCount)
+            this.submitCount = 0;
+        for (const [path, state] of this.fieldStateStore.entries()) {
+            state.isDirty = !!this.dirtyFields[path];
+            state.isTouched = !!this.touchedFields[path];
+        }
+    }
+    /**
+     * Resets one field to its current default value and clears its state.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#resetfieldname)
+     */
+    resetField(name, options = {}) {
+        const path = name;
+        this.validator.cancelDelayed(path);
+        this.touchedValidationFields.delete(path);
+        this.fieldValidationVersions.set(path, (this.fieldValidationVersions.get(path) ?? 0) + 1);
+        if ('defaultValue' in options)
+            setAtPath(this.defaultValues, path, clone(options.defaultValue));
+        setAtPath(this.values, path, clone('defaultValue' in options ? options.defaultValue : getAtPath(this.defaultValues, path)));
+        if (!options.keepError)
+            this.applyError(path, undefined);
+        if (!options.keepDirty)
+            delete this.dirtyFields[path];
+        if (!options.keepTouched)
+            delete this.touchedFields[path];
+        delete this.validatingFields[path];
+        const state = this.ensureFieldState(path);
+        if (!options.keepError)
+            this.applyFieldState(state, undefined);
+        state.isDirty = options.keepDirty ? !!this.dirtyFields[path] : false;
+        state.isTouched = options.keepTouched ? !!this.touchedFields[path] : false;
+        state.isValidating = false;
+    }
+    /**
+     * Focuses a registered field when its ref points to a focusable element.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#setfocusname)
+     */
+    setFocus(name) { this.refs.get(name)?.current?.focus(); }
+    /**
+     * Returns a plain copy of the current values.
+     *
+     * [**Documentation**](https://js2me.github.io/mobx-formly/api/form.html#snapshot)
+     */
+    get snapshot() { return clone(this.values); }
+    /** Reconciles dirty paths against the complete current value tree. */
+    syncDirtyFields(paths) {
+        const dirty = new Set(paths);
+        this.dirtyFields = Object.fromEntries(paths.map((path) => [path, true]));
+        for (const [path, state] of this.fieldStateStore.entries())
+            state.isDirty = dirty.has(path);
+        for (const path of paths)
+            this.ensureFieldState(path).isDirty = true;
+    }
+    /** Clears an exact error path and every nested error below it. */
+    clearErrorPath(path) {
+        const paths = this.errorStore.paths().filter((stored) => stored === path || stored.startsWith(`${path}.`));
+        if (!paths.length) {
+            this.validator.cancelDelayed(path);
+            this.applyError(path, undefined);
+            return;
+        }
+        for (const storedPath of paths) {
+            this.validator.cancelDelayed(storedPath);
+            this.applyError(storedPath, undefined);
+        }
+    }
+    /** Focuses the first errored registered field, skipping form-level errors. */
+    focusFirstError(paths) {
+        const candidates = paths ?? this.errorStore.paths();
+        for (const path of candidates) {
+            if (!this.hasError(path))
+                continue;
+            const ref = this.refs.get(path)?.current;
+            if (ref?.focus) {
+                ref.focus();
+                return;
+            }
+        }
+    }
+    dependentFields(deps) {
+        if (!deps)
+            return [];
+        return (Array.isArray(deps) ? deps : [deps]).map(String);
+    }
+    markTouched(path) {
+        this.touchedFields[path] = true;
+        this.ensureFieldState(path).isTouched = true;
+    }
+    updateDirty(path) {
+        if (isEqual(getAtPath(this.values, path), getAtPath(this.defaultValues, path)))
+            delete this.dirtyFields[path];
+        else
+            this.dirtyFields[path] = true;
+        this.ensureFieldState(path).isDirty = !!this.dirtyFields[path];
+    }
+    shouldValidateOnChange(path) {
+        return this.options.mode === 'onChange'
+            || this.options.mode === 'all'
+            || (this.options.mode === 'onTouched' && this.touchedValidationFields.has(path))
+            || (this.hasError(path) && this.options.reValidateMode === 'onChange');
+    }
+    isValidationCurrent(path, run, fieldVersions) {
+        if (this.validationVersion !== run)
+            return false;
+        const version = fieldVersions.get(path);
+        return version === undefined
+            || (this.fieldOptions.has(path) && (this.fieldValidationVersions.get(path) ?? 0) === version);
+    }
+    transformValue(value, options) {
+        if (options.setValueAs)
+            return options.setValueAs(value);
+        if (options.valueAsNumber)
+            return value === '' ? Number.NaN : Number(value);
+        if (options.valueAsDate)
+            return new Date(String(value));
+        return value;
+    }
+    ensureFieldState(path) {
+        return this.fieldStateStore.ensure(path, () => ({ invalid: false, isDirty: false, isTouched: false, isValidating: false, error: undefined }));
+    }
+    applyFieldState(state, error) {
+        state.error = error;
+        state.invalid = !!error;
+    }
+    applyError(path, error) {
+        this.isValidOverride.set(undefined);
+        if (error)
+            this.errorStore.set(path, error);
+        else
+            this.errorStore.delete(path);
+        const state = this.ensureFieldState(path);
+        state.error = error;
+        state.invalid = !!error;
+    }
+    hasError(path) { return this.errorStore.has(path); }
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { BaseForm } from './form.js';
+export type { Form } from './form.js';
+export { createForm } from './create-form.js';
+export type { InferredFormValues } from './create-form.js';
+export type { ErrorNamespacePath, FieldError, FieldErrors, FieldPath, FieldPathValue, FieldState, FieldStateTree, FieldValues, FieldValidate, FormOptions, FormSchema, GlobalErrors, ResetFieldOptions, SafeParseFormSchema, SchemaIssue, SchemaOutput, SchemaResult, StandardFormSchema, StandardSchemaIssue, StandardSchemaResult, ValibotFormSchema, ValibotRunResult, ValidateResult, Resolver, ResolverOptions, ResolverResult, RegisterOptions, RegisterReturn, ResetOptions, SetErrorConfig, SetValueConfig, SubmitHandlers, TriggerConfig, } from './types.js';

package/dist/index.js

@@ -0,0 +1,2 @@
+export { BaseForm } from './form.js';
+export { createForm } from './create-form.js';

package/dist/path-store.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Path-indexed observable store with lazy nested proxies.
+ *
+ * Values are stored flat by dot-separated path while reads go through
+ * stable proxies that expose the same data as a nested tree. A reverse
+ * index of path counts and children sets keeps parent branches alive
+ * while any child path exists.
+ */
+export declare class PathStore<V extends object> {
+    private readonly store;
+    private readonly counts;
+    private readonly children;
+    private readonly proxies;
+    /** Whether a value is stored at the exact path. */
+    has(path: string): boolean;
+    /** Number of stored values. */
+    get size(): number;
+    /** Returns the stored value at the exact path. */
+    get(path: string): V | undefined;
+    /** All stored path and value pairs. */
+    entries(): Array<[string, V]>;
+    /** All stored paths. */
+    paths(): string[];
+    /** Stores a value and registers its path in the reverse index. */
+    set(path: string, value: V): void;
+    /** Removes a value and prunes empty parent branches of the index. */
+    delete(path: string): void;
+    /** Removes all values and index data. */
+    clear(): void;
+    /** Returns the stored value or creates, stores, and returns it. */
+    ensure(path: string, create: () => V): V;
+    /** Returns the stable read-only nested view of the stored values. */
+    proxy(): object;
+    private createProxy;
+    /** Drops cached proxies for the removed path and its children so churn does not accumulate. */
+    private evictProxies;
+    private addPathToIndex;
+}