@milaboratories/pl-tree 1.7.5 → 1.7.7

package/dist/state.js

@@ -0,0 +1,627 @@
+import { resourceIdToString, isNotNullResourceId, NullResourceId, isNullResourceId, stringifyWithResourceId } from '@milaboratories/pl-client';
+import { ChangeSource, KeyedChangeSource } from '@milaboratories/computable';
+import { PlTreeEntry } from './accessors.js';
+import { cachedDecode, cachedDeserialize, notEmpty } from '@milaboratories/ts-helpers';
+
+class TreeStateUpdateError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+class PlTreeField {
+    name;
+    type;
+    value;
+    error;
+    status;
+    valueIsFinal;
+    resourceVersion;
+    change = new ChangeSource();
+    constructor(name, type, value, error, status, valueIsFinal, 
+    /** Last version of resource this field was observed, used to garbage collect fields in tree patching procedure */
+    resourceVersion) {
+        this.name = name;
+        this.type = type;
+        this.value = value;
+        this.error = error;
+        this.status = status;
+        this.valueIsFinal = valueIsFinal;
+        this.resourceVersion = resourceVersion;
+    }
+    get state() {
+        return {
+            name: this.name,
+            type: this.type,
+            status: this.status,
+            value: this.value,
+            error: this.error,
+            valueIsFinal: this.valueIsFinal,
+        };
+    }
+}
+const InitialResourceVersion = 0;
+/** Never store instances of this class, always get fresh instance from {@link PlTreeState} */
+class PlTreeResource {
+    /** Tracks number of other resources referencing this resource. Used to perform garbage collection in tree patching procedure */
+    refCount = 0;
+    /** Increments each time resource is checked for difference with new state */
+    version = InitialResourceVersion;
+    /** Set to resource version when resource state, or it's fields have changed */
+    dataVersion = InitialResourceVersion;
+    fieldsMap = new Map();
+    kv = new Map();
+    resourceRemoved = new ChangeSource();
+    // following change source are removed when resource is marked as final
+    finalChanged = new ChangeSource();
+    resourceStateChange = new ChangeSource();
+    lockedChange = new ChangeSource();
+    inputAndServiceFieldListChanged = new ChangeSource();
+    outputFieldListChanged = new ChangeSource();
+    dynamicFieldListChanged = new ChangeSource();
+    // kvChangedGlobal? = new ChangeSource();
+    kvChangedPerKey = new KeyedChangeSource();
+    id;
+    originalResourceId;
+    kind;
+    type;
+    data;
+    dataAsString;
+    dataAsJson;
+    error;
+    inputsLocked;
+    outputsLocked;
+    resourceReady;
+    finalFlag;
+    /** Set externally by the tree, using {@link FinalResourceDataPredicate} */
+    _finalState = false;
+    logger;
+    constructor(initialState, logger) {
+        this.id = initialState.id;
+        this.originalResourceId = initialState.originalResourceId;
+        this.kind = initialState.kind;
+        this.type = initialState.type;
+        this.data = initialState.data;
+        this.error = initialState.error;
+        this.inputsLocked = initialState.inputsLocked;
+        this.outputsLocked = initialState.outputsLocked;
+        this.resourceReady = initialState.resourceReady;
+        this.finalFlag = initialState.final;
+        this.logger = logger;
+    }
+    // TODO add logging
+    info(msg) {
+        if (this.logger !== undefined)
+            this.logger.info(msg);
+    }
+    warn(msg) {
+        if (this.logger !== undefined)
+            this.logger.warn(msg);
+    }
+    get final() {
+        return this.finalFlag;
+    }
+    get finalState() {
+        return this._finalState;
+    }
+    get fields() {
+        return [...this.fieldsMap.values()];
+    }
+    getField(watcher, _step, onUnstable = () => { }) {
+        const step = typeof _step === 'string' ? { field: _step } : _step;
+        const field = this.fieldsMap.get(step.field);
+        if (field === undefined) {
+            if (step.errorIfFieldNotFound || step.errorIfFieldNotSet)
+                throw new Error(`Field "${step.field}" not found in resource ${resourceIdToString(this.id)}`);
+            if (!this.inputsLocked)
+                this.inputAndServiceFieldListChanged?.attachWatcher(watcher);
+            else if (step.assertFieldType === 'Service' || step.assertFieldType === 'Input') {
+                if (step.allowPermanentAbsence)
+                    // stable absence of field
+                    return undefined;
+                else
+                    throw new Error(`Service or input field not found ${step.field}.`);
+            }
+            if (!this.outputsLocked)
+                this.outputFieldListChanged?.attachWatcher(watcher);
+            else if (step.assertFieldType === 'Output') {
+                if (step.allowPermanentAbsence)
+                    // stable absence of field
+                    return undefined;
+                else
+                    throw new Error(`Output field not found ${step.field}.`);
+            }
+            this.dynamicFieldListChanged?.attachWatcher(watcher);
+            if (!this._finalState && !step.stableIfNotFound)
+                onUnstable('field_not_found:' + step.field);
+            return undefined;
+        }
+        else {
+            if (step.assertFieldType !== undefined && field.type !== step.assertFieldType)
+                throw new Error(`Unexpected field type: expected ${step.assertFieldType} but got ${field.type} for the field name ${step.field}`);
+            const ret = {};
+            if (isNotNullResourceId(field.value))
+                ret.value = field.value;
+            if (isNotNullResourceId(field.error))
+                ret.error = field.error;
+            if (ret.value === undefined && ret.error === undefined)
+                // this method returns value and error of the field, thus those values are considered to be accessed;
+                // any existing but not resolved field here is considered to be unstable, in the sense it is
+                // considered to acquire some resolved value eventually
+                onUnstable('field_not_resolved:' + step.field);
+            field.change.attachWatcher(watcher);
+            return ret;
+        }
+    }
+    getInputsLocked(watcher) {
+        if (!this.inputsLocked)
+            // reverse transition can't happen, so there is no reason to wait for value to change
+            this.resourceStateChange?.attachWatcher(watcher);
+        return this.inputsLocked;
+    }
+    getOutputsLocked(watcher) {
+        if (!this.outputsLocked)
+            // reverse transition can't happen, so there is no reason to wait for value to change
+            this.resourceStateChange?.attachWatcher(watcher);
+        return this.outputsLocked;
+    }
+    get isReadyOrError() {
+        return (this.error !== NullResourceId
+            || this.resourceReady
+            || this.originalResourceId !== NullResourceId);
+    }
+    getIsFinal(watcher) {
+        this.finalChanged?.attachWatcher(watcher);
+        return this._finalState;
+    }
+    getIsReadyOrError(watcher) {
+        if (!this.isReadyOrError)
+            // reverse transition can't happen, so there is no reason to wait for value to change if it is already true
+            this.resourceStateChange?.attachWatcher(watcher);
+        return this.isReadyOrError;
+    }
+    getError(watcher) {
+        if (isNullResourceId(this.error)) {
+            this.resourceStateChange?.attachWatcher(watcher);
+            return undefined;
+        }
+        else {
+            // reverse transition can't happen, so there is no reason to wait for value to change, if error already set
+            return this.error;
+        }
+    }
+    listInputFields(watcher) {
+        const ret = [];
+        this.fieldsMap.forEach((field, name) => {
+            if (field.type === 'Input' || field.type === 'Service')
+                ret.push(name);
+        });
+        if (!this.inputsLocked)
+            this.inputAndServiceFieldListChanged?.attachWatcher(watcher);
+        return ret;
+    }
+    listOutputFields(watcher) {
+        const ret = [];
+        this.fieldsMap.forEach((field, name) => {
+            if (field.type === 'Output')
+                ret.push(name);
+        });
+        if (!this.outputsLocked)
+            this.outputFieldListChanged?.attachWatcher(watcher);
+        return ret;
+    }
+    listDynamicFields(watcher) {
+        const ret = [];
+        this.fieldsMap.forEach((field, name) => {
+            if (field.type !== 'Input' && field.type !== 'Output')
+                ret.push(name);
+        });
+        this.dynamicFieldListChanged?.attachWatcher(watcher);
+        return ret;
+    }
+    getKeyValue(watcher, key) {
+        this.kvChangedPerKey?.attachWatcher(key, watcher);
+        return this.kv.get(key);
+    }
+    getKeyValueString(watcher, key) {
+        const bytes = this.getKeyValue(watcher, key);
+        if (bytes === undefined)
+            return undefined;
+        return cachedDecode(bytes);
+    }
+    getKeyValueAsJson(watcher, key) {
+        const bytes = this.getKeyValue(watcher, key);
+        if (bytes === undefined)
+            return undefined;
+        return cachedDeserialize(bytes);
+    }
+    getDataAsString() {
+        if (this.data === undefined)
+            return undefined;
+        if (this.dataAsString === undefined)
+            this.dataAsString = cachedDecode(this.data);
+        return this.dataAsString;
+    }
+    getDataAsJson() {
+        if (this.data === undefined)
+            return undefined;
+        if (this.dataAsJson === undefined)
+            this.dataAsJson = cachedDeserialize(this.data);
+        return this.dataAsJson;
+    }
+    verifyReadyState() {
+        if (this.resourceReady && !this.inputsLocked)
+            throw new Error(`ready without input or output lock: ${stringifyWithResourceId(this.basicState)}`);
+    }
+    get basicState() {
+        return {
+            id: this.id,
+            kind: this.kind,
+            type: this.type,
+            data: this.data,
+            resourceReady: this.resourceReady,
+            inputsLocked: this.inputsLocked,
+            outputsLocked: this.outputsLocked,
+            error: this.error,
+            originalResourceId: this.originalResourceId,
+            final: this.finalFlag,
+        };
+    }
+    get extendedState() {
+        return {
+            ...this.basicState,
+            fields: this.fields,
+            kv: Array.from(this.kv.entries()).map(([key, value]) => ({ key, value })),
+        };
+    }
+    /** Called when {@link FinalResourceDataPredicate} returns true for the state. */
+    markFinal() {
+        if (this._finalState)
+            return;
+        this._finalState = true;
+        notEmpty(this.finalChanged).markChanged('marked final');
+        this.finalChanged = undefined;
+        this.resourceStateChange = undefined;
+        this.dynamicFieldListChanged = undefined;
+        this.inputAndServiceFieldListChanged = undefined;
+        this.outputFieldListChanged = undefined;
+        this.lockedChange = undefined;
+        // this.kvChangedGlobal = undefined;
+        this.kvChangedPerKey = undefined;
+    }
+    /** Used for invalidation */
+    markAllChanged() {
+        this.fieldsMap.forEach((field) => field.change.markChanged('marked all changed'));
+        this.finalChanged?.markChanged('marked all changed');
+        this.resourceStateChange?.markChanged('marked all changed');
+        this.lockedChange?.markChanged('marked all changed');
+        this.inputAndServiceFieldListChanged?.markChanged('marked all changed');
+        this.outputFieldListChanged?.markChanged('marked all changed');
+        this.dynamicFieldListChanged?.markChanged('marked all changed');
+        // this.kvChangedGlobal?.markChanged('marked all changed');
+        this.kvChangedPerKey?.markAllChanged('marked all changed');
+        this.resourceRemoved.markChanged('marked all changed');
+    }
+}
+class PlTreeState {
+    root;
+    isFinalPredicate;
+    /** resource heap */
+    resources = new Map();
+    resourcesAdded = new ChangeSource();
+    /** Resets to false if any invalid state transitions are registered,
+     * after that tree will produce errors for any read or write operations */
+    _isValid = true;
+    invalidationMessage;
+    constructor(
+    /** This will be the only resource not deleted during GC round */
+    root, isFinalPredicate) {
+        this.root = root;
+        this.isFinalPredicate = isFinalPredicate;
+    }
+    forEachResource(cb) {
+        this.resources.forEach((v) => cb(v));
+    }
+    checkValid() {
+        if (!this._isValid)
+            throw new Error(this.invalidationMessage ?? 'tree is in invalid state');
+    }
+    get(watcher, rid) {
+        this.checkValid();
+        const res = this.resources.get(rid);
+        if (res === undefined) {
+            // to make recovery from resource not found possible, considering some
+            // race conditions, where computable is created before tree is updated
+            this.resourcesAdded.attachWatcher(watcher);
+            throw new Error(`resource ${resourceIdToString(rid)} not found in the tree`);
+        }
+        res.resourceRemoved.attachWatcher(watcher);
+        return res;
+    }
+    updateFromResourceData(resourceData, allowOrphanInputs = false) {
+        this.checkValid();
+        // All resources for which recount should be incremented, first are aggregated in this list
+        const incrementRefs = [];
+        const decrementRefs = [];
+        // patching / creating resources
+        for (const rd of resourceData) {
+            let resource = this.resources.get(rd.id);
+            const statBeforeMutation = resource?.basicState;
+            const unexpectedTransitionError = (reason) => {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                const { fields, ...rdWithoutFields } = rd;
+                this.invalidateTree();
+                throw new TreeStateUpdateError(`Unexpected resource state transition (${reason}): ${stringifyWithResourceId(rdWithoutFields)} -> ${stringifyWithResourceId(statBeforeMutation)}`);
+            };
+            if (resource !== undefined) {
+                // updating existing resource
+                if (resource.finalState)
+                    unexpectedTransitionError('resource state can\t be updated after it is marked as final');
+                let changed = false;
+                // updating resource version, even if it was not changed
+                resource.version += 1;
+                // duplicate / original
+                if (resource.originalResourceId !== rd.originalResourceId) {
+                    if (resource.originalResourceId !== NullResourceId)
+                        unexpectedTransitionError('originalResourceId can\'t change after it is set');
+                    resource.originalResourceId = rd.originalResourceId;
+                    // duplicate status of the resource counts as ready for the external observer
+                    notEmpty(resource.resourceStateChange).markChanged(`originalResourceId changed for ${resourceIdToString(resource.id)}`);
+                    changed = true;
+                }
+                // error
+                if (resource.error !== rd.error) {
+                    if (isNotNullResourceId(resource.error))
+                        unexpectedTransitionError('resource can\'t change attached error after it is set');
+                    resource.error = rd.error;
+                    incrementRefs.push(resource.error);
+                    notEmpty(resource.resourceStateChange).markChanged(`error changed for ${resourceIdToString(resource.id)}`);
+                    changed = true;
+                }
+                // updating fields
+                for (const fd of rd.fields) {
+                    let field = resource.fieldsMap.get(fd.name);
+                    if (!field) {
+                        // new field
+                        field = new PlTreeField(fd.name, fd.type, fd.value, fd.error, fd.status, fd.valueIsFinal, resource.version);
+                        if (isNotNullResourceId(fd.value))
+                            incrementRefs.push(fd.value);
+                        if (isNotNullResourceId(fd.error))
+                            incrementRefs.push(fd.error);
+                        if (fd.type === 'Input' || fd.type === 'Service') {
+                            if (resource.inputsLocked)
+                                unexpectedTransitionError(`adding ${fd.type} (${fd.name}) field while inputs locked`);
+                            notEmpty(resource.inputAndServiceFieldListChanged).markChanged(`new ${fd.type} field ${fd.name} added to ${resourceIdToString(resource.id)}`);
+                        }
+                        else if (fd.type === 'Output') {
+                            if (resource.outputsLocked)
+                                unexpectedTransitionError(`adding ${fd.type} (${fd.name}) field while outputs locked`);
+                            notEmpty(resource.outputFieldListChanged).markChanged(`new ${fd.type} field ${fd.name} added to ${resourceIdToString(resource.id)}`);
+                        }
+                        else {
+                            notEmpty(resource.dynamicFieldListChanged).markChanged(`new ${fd.type} field ${fd.name} added to ${resourceIdToString(resource.id)}`);
+                        }
+                        resource.fieldsMap.set(fd.name, field);
+                        changed = true;
+                    }
+                    else {
+                        // change of old field
+                        // in principle this transition is possible, see assertions below
+                        if (field.type !== fd.type) {
+                            if (field.type !== 'Dynamic')
+                                unexpectedTransitionError(`field changed type ${field.type} -> ${fd.type}`);
+                            notEmpty(resource.dynamicFieldListChanged).markChanged(`field ${fd.name} changed type from Dynamic to ${fd.type} in ${resourceIdToString(resource.id)}`);
+                            if (field.type === 'Input' || field.type === 'Service') {
+                                if (resource.inputsLocked)
+                                    unexpectedTransitionError(`adding input field "${fd.name}", while corresponding list is locked`);
+                                notEmpty(resource.inputAndServiceFieldListChanged).markChanged(`field ${fd.name} changed to type ${fd.type} in ${resourceIdToString(resource.id)}`);
+                            }
+                            if (field.type === 'Output') {
+                                if (resource.outputsLocked)
+                                    unexpectedTransitionError(`adding output field "${fd.name}", while corresponding list is locked`);
+                                notEmpty(resource.outputFieldListChanged).markChanged(`field ${fd.name} changed to type ${fd.type} in ${resourceIdToString(resource.id)}`);
+                            }
+                            field.type = fd.type;
+                            field.change.markChanged(`field ${fd.name} type changed to ${fd.type} in ${resourceIdToString(resource.id)}`);
+                            changed = true;
+                        }
+                        // field value
+                        if (field.value !== fd.value) {
+                            if (isNotNullResourceId(field.value))
+                                decrementRefs.push(field.value);
+                            field.value = fd.value;
+                            if (isNotNullResourceId(fd.value))
+                                incrementRefs.push(fd.value);
+                            field.change.markChanged(`field ${fd.name} value changed in ${resourceIdToString(resource.id)}`);
+                            changed = true;
+                        }
+                        // field error
+                        if (field.error !== fd.error) {
+                            if (isNotNullResourceId(field.error))
+                                decrementRefs.push(field.error);
+                            field.error = fd.error;
+                            if (isNotNullResourceId(fd.error))
+                                incrementRefs.push(fd.error);
+                            field.change.markChanged(`field ${fd.name} error changed in ${resourceIdToString(resource.id)}`);
+                            changed = true;
+                        }
+                        // field status
+                        if (field.status !== fd.status) {
+                            field.status = fd.status;
+                            field.change.markChanged(`field ${fd.name} status changed to ${fd.status} in ${resourceIdToString(resource.id)}`);
+                            changed = true;
+                        }
+                        // field valueIsFinal flag
+                        if (field.valueIsFinal !== fd.valueIsFinal) {
+                            field.valueIsFinal = fd.valueIsFinal;
+                            field.change.markChanged(`field ${fd.name} valueIsFinal changed to ${fd.valueIsFinal} in ${resourceIdToString(resource.id)}`);
+                            changed = true;
+                        }
+                        field.resourceVersion = resource.version;
+                    }
+                }
+                // detecting removed fields
+                resource.fieldsMap.forEach((field, fieldName, fields) => {
+                    if (field.resourceVersion !== resource.version) {
+                        if (field.type === 'Input' || field.type === 'Service' || field.type === 'Output')
+                            unexpectedTransitionError(`removal of ${field.type} field ${fieldName}`);
+                        field.change.markChanged(`dynamic field ${fieldName} removed from ${resourceIdToString(resource.id)}`);
+                        fields.delete(fieldName);
+                        if (isNotNullResourceId(field.value))
+                            decrementRefs.push(field.value);
+                        if (isNotNullResourceId(field.error))
+                            decrementRefs.push(field.error);
+                        notEmpty(resource.dynamicFieldListChanged).markChanged(`dynamic field ${fieldName} removed from ${resourceIdToString(resource.id)}`);
+                    }
+                });
+                // inputsLocked
+                if (resource.inputsLocked !== rd.inputsLocked) {
+                    if (resource.inputsLocked)
+                        unexpectedTransitionError('inputs unlocking is not permitted');
+                    resource.inputsLocked = rd.inputsLocked;
+                    notEmpty(resource.lockedChange).markChanged(`inputs locked for ${resourceIdToString(resource.id)}`);
+                    changed = true;
+                }
+                // outputsLocked
+                if (resource.outputsLocked !== rd.outputsLocked) {
+                    if (resource.outputsLocked)
+                        unexpectedTransitionError('outputs unlocking is not permitted');
+                    resource.outputsLocked = rd.outputsLocked;
+                    notEmpty(resource.lockedChange).markChanged(`outputs locked for ${resourceIdToString(resource.id)}`);
+                    changed = true;
+                }
+                // ready flag
+                if (resource.resourceReady !== rd.resourceReady) {
+                    const readyStateBefore = resource.resourceReady;
+                    resource.resourceReady = rd.resourceReady;
+                    resource.verifyReadyState();
+                    if (!resource.isReadyOrError)
+                        unexpectedTransitionError(`resource can't lose it's ready or error state (ready state before ${readyStateBefore})`);
+                    notEmpty(resource.resourceStateChange).markChanged(`ready flag changed to ${rd.resourceReady} for ${resourceIdToString(resource.id)}`);
+                    changed = true;
+                }
+                // syncing kv
+                for (const kv of rd.kv) {
+                    const current = resource.kv.get(kv.key);
+                    if (current === undefined) {
+                        resource.kv.set(kv.key, kv.value);
+                        notEmpty(resource.kvChangedPerKey).markChanged(kv.key, `kv added for ${resourceIdToString(resource.id)}: ${kv.key}`);
+                    }
+                    else if (Buffer.compare(current, kv.value) !== 0) {
+                        resource.kv.set(kv.key, kv.value);
+                        notEmpty(resource.kvChangedPerKey).markChanged(kv.key, `kv changed for ${resourceIdToString(resource.id)}: ${kv.key}`);
+                    }
+                }
+                if (resource.kv.size > rd.kv.length) {
+                    // only it this case it makes sense to check for deletions
+                    const newStateKeys = new Set(rd.kv.map((kv) => kv.key));
+                    // deleting keys not present in resource anymore
+                    resource.kv.forEach((_value, key, map) => {
+                        if (!newStateKeys.has(key)) {
+                            map.delete(key);
+                            notEmpty(resource.kvChangedPerKey).markChanged(key, `kv deleted for ${resourceIdToString(resource.id)}: ${key}`);
+                        }
+                    });
+                }
+                if (changed) {
+                    // if resource was changed, updating resource data version
+                    resource.dataVersion = resource.version;
+                    if (this.isFinalPredicate(resource))
+                        resource.markFinal();
+                }
+            }
+            else {
+                // creating new resource
+                resource = new PlTreeResource(rd);
+                resource.verifyReadyState();
+                if (isNotNullResourceId(resource.error))
+                    incrementRefs.push(resource.error);
+                for (const fd of rd.fields) {
+                    const field = new PlTreeField(fd.name, fd.type, fd.value, fd.error, fd.status, fd.valueIsFinal, InitialResourceVersion);
+                    if (isNotNullResourceId(fd.value))
+                        incrementRefs.push(fd.value);
+                    if (isNotNullResourceId(fd.error))
+                        incrementRefs.push(fd.error);
+                    resource.fieldsMap.set(fd.name, field);
+                }
+                // adding kv
+                for (const kv of rd.kv)
+                    resource.kv.set(kv.key, kv.value);
+                // checking that resource is final, and if so, marking it
+                if (this.isFinalPredicate(resource))
+                    resource.markFinal();
+                // adding the resource to the heap
+                this.resources.set(resource.id, resource);
+                this.resourcesAdded.markChanged(`new resource ${resourceIdToString(resource.id)} added`);
+            }
+        }
+        // applying refCount increments
+        for (const rid of incrementRefs) {
+            const res = this.resources.get(rid);
+            if (!res) {
+                this.invalidateTree();
+                throw new TreeStateUpdateError(`orphan resource ${rid}`);
+            }
+            res.refCount++;
+        }
+        // recursively applying refCount decrements / doing garbage collection
+        let currentRefs = decrementRefs;
+        while (currentRefs.length > 0) {
+            const nextRefs = [];
+            for (const rid of currentRefs) {
+                const res = this.resources.get(rid);
+                if (!res) {
+                    this.invalidateTree();
+                    throw new TreeStateUpdateError(`orphan resource ${rid}`);
+                }
+                res.refCount--;
+                // garbage collection
+                if (res.refCount === 0 && res.id !== this.root) {
+                    // removing fields
+                    res.fieldsMap.forEach((field) => {
+                        if (isNotNullResourceId(field.value))
+                            nextRefs.push(field.value);
+                        if (isNotNullResourceId(field.error))
+                            nextRefs.push(field.error);
+                        field.change.markChanged(`field ${field.name} removed during garbage collection of ${resourceIdToString(res.id)}`);
+                    });
+                    if (isNotNullResourceId(res.error))
+                        nextRefs.push(res.error);
+                    res.resourceRemoved.markChanged(`resource removed during garbage collection: ${resourceIdToString(res.id)}`);
+                    this.resources.delete(rid);
+                }
+            }
+            currentRefs = nextRefs;
+        }
+        // checking for orphans (maybe removed in the future)
+        if (!allowOrphanInputs) {
+            for (const rd of resourceData) {
+                if (!this.resources.has(rd.id)) {
+                    this.invalidateTree();
+                    throw new TreeStateUpdateError(`orphan input resource ${rd.id}`);
+                }
+            }
+        }
+    }
+    /** @deprecated use "entry" instead */
+    accessor(rid = this.root) {
+        this.checkValid();
+        return this.entry(rid);
+    }
+    entry(rid = this.root) {
+        this.checkValid();
+        return new PlTreeEntry({ treeProvider: () => this }, rid);
+    }
+    invalidateTree(msg) {
+        this._isValid = false;
+        this.invalidationMessage = msg;
+        this.resources.forEach((res) => {
+            res.markAllChanged();
+        });
+    }
+    dumpState() {
+        return Array.from(this.resources.values()).map((res) => res.extendedState);
+    }
+}
+
+export { PlTreeResource, PlTreeState, TreeStateUpdateError };
+//# sourceMappingURL=state.js.map