@fastybird/smart-panel-backend 1.1.0-alpha.64 → 1.1.0-alpha.66

package/dist/modules/devices/services/property-producer.registry.service.js

@@ -0,0 +1,636 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PropertyProducerRegistryService = void 0;
+const common_1 = require("@nestjs/common");
+const event_emitter_1 = require("@nestjs/event-emitter");
+const devices_constants_1 = require("../devices.constants");
+const property_value_state_model_1 = require("../models/property-value-state.model");
+const creation_capture_1 = require("./creation-capture");
+function privateStateToken() {
+    return Object.freeze({ toJSON: () => ({}) });
+}
+function detachedStateValue(value) {
+    const owned = (0, creation_capture_1.snapshotCreation)(value);
+    const seen = new Set();
+    const freeze = (item) => {
+        if (!item || typeof item !== 'object' || seen.has(item))
+            return;
+        seen.add(item);
+        for (const key of Object.keys(item))
+            freeze(Reflect.get(item, key));
+        Object.freeze(item);
+    };
+    freeze(owned);
+    return owned;
+}
+let PropertyProducerRegistryService = class PropertyProducerRegistryService {
+    advanceSlot(id) {
+        this.slotVersions.set(id, (this.slotVersions.get(id) ?? 0) + 1);
+    }
+    forgetSlot(id) {
+        this.removalEpoch = {};
+        this.slotVersions.delete(id);
+    }
+    createStateOwner(family) {
+        const token = privateStateToken();
+        this.stateOwners.set(token, { family, lifecycle: this.stateLifecycle, active: true, slots: new Map() });
+        return token;
+    }
+    beginStateBatch(owner, current, ready) {
+        const record = this.stateOwners.get(owner);
+        const lifecycle = this.stateLifecycle;
+        if (!record?.active || record.lifecycle !== this.stateLifecycle)
+            throw new Error('Producer state owner is closed');
+        const pins = (0, creation_capture_1.captureCreation)(this, [
+            'createStateOwner',
+            'beginStateBatch',
+            'prepareStateBatch',
+            'installStatePlan',
+            'publishStatePlan',
+            'disposeStateOwner',
+            'validateStatePlan',
+            'readStatePlan',
+            'closeStateBatch',
+            'register',
+            'owns',
+            'isCurrent',
+        ]);
+        const eventPins = this.events && (0, creation_capture_1.captureCreation)(this.events, ['emit']);
+        const originalEmit = this.emit.bind(this);
+        const dispatch = eventPins
+            ? (property) => {
+                eventPins.values.emit.call(eventPins.receiver, devices_constants_1.EventType.CHANNEL_PROPERTY_VALUE_STATE_CHANGED, property);
+            }
+            : null;
+        const emission = (property, state) => originalEmit(property, state, dispatch);
+        const token = privateStateToken();
+        this.stateBatches.set(token, {
+            owner: record,
+            entries: new Map(this.entries),
+            versions: new Map(this.slotVersions),
+            removalEpoch: this.removalEpoch,
+            current: () => lifecycle === this.stateLifecycle &&
+                record.active &&
+                pins.current() &&
+                (!eventPins || eventPins.current()) &&
+                current(),
+            ready,
+            emit: emission,
+            active: true,
+        });
+        return token;
+    }
+    prepareStateBatch(token, intents, removeMissing = true, replaceOwned = true, restore, replaceOriginalConfigurationSlots = new Set(), allowAbsent = true) {
+        const batch = this.stateBatches.get(token);
+        if (!batch?.active || !batch.current())
+            throw new Error('Producer state batch expired');
+        const owned = detachedStateValue(intents);
+        const ids = new Set();
+        const operations = [];
+        for (const intent of owned) {
+            const id = intent.property.id;
+            if (!id || ids.has(id) || !Number.isSafeInteger(intent.revision) || intent.revision < 0)
+                throw new Error('Invalid producer state intent');
+            ids.add(id);
+            const previous = batch.entries.get(id);
+            if (!previous && intent.reason === 'runtime_unavailable' && allowAbsent !== true && !allowAbsent.has(id))
+                continue;
+            if (previous && !replaceOwned && !previous.retiredByUnregister)
+                continue;
+            if (previous &&
+                previous.ownedState !== batch.owner &&
+                !previous.retiredByUnregister &&
+                !replaceOriginalConfigurationSlots.has(id) &&
+                !(previous.ownedState?.family === batch.owner.family && !previous.ownedState.active))
+                continue;
+            const state = this.unavailable(intent.revision, [intent.reason], new Date());
+            operations.push({
+                id,
+                previous,
+                next: {
+                    property: intent.property,
+                    lease: Object.freeze({ propertyId: id, revision: intent.revision }),
+                    state,
+                    epoch: (previous?.epoch ?? 0) + 1,
+                    generation: 0,
+                    publication: 0,
+                    ownedState: batch.owner,
+                    guard: Object.freeze({
+                        isCurrent: () => batch.owner.active && batch.ready(),
+                        reason: 'graph_validation_pending',
+                    }),
+                },
+            });
+        }
+        if (removeMissing)
+            for (const [id, previous] of batch.owner.slots)
+                if (!ids.has(id) && batch.entries.get(id) === previous)
+                    operations.push({ id, previous });
+        const plan = privateStateToken();
+        this.statePlans.set(plan, {
+            batch,
+            operations: Object.freeze(operations),
+            restore,
+            published: false,
+            report: {
+                attempted: operations.length,
+                installed: 0,
+                submitted: 0,
+                settled: 0,
+                failed: 0,
+                retired: false,
+                terminal: 'prepared',
+            },
+        });
+        return plan;
+    }
+    validateStatePlan(token) {
+        const plan = this.statePlans.get(token);
+        if (!plan || !plan.batch.current())
+            return false;
+        if (plan.report.terminal === 'prepared')
+            return (plan.batch.active &&
+                plan.operations.every(({ id, previous }) => this.entries.get(id) === previous &&
+                    (previous !== undefined || plan.batch.removalEpoch === this.removalEpoch) &&
+                    (this.slotVersions.get(id) ?? 0) === (plan.batch.versions.get(id) ?? 0)));
+        return ((plan.report.terminal === 'installed' || plan.report.terminal === 'complete') &&
+            plan.report.failed === 0 &&
+            plan.operations.every(({ id, next }) => this.entries.get(id) === next &&
+                (next === undefined
+                    ? plan.removalEpoch === this.removalEpoch
+                    : (this.slotVersions.get(id) ?? 0) === (plan.batch.versions.get(id) ?? 0) + 1)));
+    }
+    installStatePlan(token) {
+        const plan = this.statePlans.get(token);
+        if (!plan || plan.report.terminal !== 'prepared')
+            return false;
+        if (!this.validateStatePlan(token)) {
+            plan.report.retired = true;
+            plan.report.terminal = 'refused';
+            plan.batch.active = false;
+            return false;
+        }
+        for (const { id, next } of plan.operations) {
+            if (next) {
+                this.entries.set(id, next);
+                plan.batch.owner.slots.set(id, next);
+                this.advanceSlot(id);
+            }
+            else {
+                this.entries.delete(id);
+                plan.batch.owner.slots.delete(id);
+                this.forgetSlot(id);
+            }
+            plan.report.installed++;
+        }
+        plan.removalEpoch = this.removalEpoch;
+        plan.report.terminal = 'installed';
+        return true;
+    }
+    publishStatePlan(token) {
+        const plan = this.statePlans.get(token);
+        if (!plan || plan.report.terminal !== 'installed' || plan.published)
+            throw new Error('Producer state publication is closed');
+        plan.published = true;
+        let failure;
+        const failed = (cause) => {
+            plan.report.failed++;
+            failure ??= { cause };
+        };
+        const finish = () => {
+            plan.report.retired ||= !plan.batch.current();
+            plan.report.terminal = failure ? 'partial' : 'complete';
+            plan.batch.active = false;
+            if (failure)
+                throw failure.cause;
+        };
+        const run = (start) => {
+            for (let index = start; index < plan.operations.length; index++) {
+                const { id, next } = plan.operations[index];
+                if (!next && !plan.restore)
+                    continue;
+                plan.report.retired ||= !plan.batch.current() || this.entries.get(id) !== next;
+                plan.report.submitted++;
+                if (!next) {
+                    let original;
+                    try {
+                        original = plan.restore(id);
+                    }
+                    catch (cause) {
+                        failed(cause);
+                        plan.report.settled++;
+                        continue;
+                    }
+                    return original.catch(failed).then(() => {
+                        plan.report.settled++;
+                        return run(index + 1);
+                    });
+                }
+                try {
+                    plan.batch.emit(next.property, next.state);
+                }
+                catch (cause) {
+                    failed(cause);
+                }
+                finally {
+                    plan.report.settled++;
+                }
+            }
+            return finish();
+        };
+        return run(0);
+    }
+    readStatePlan(token) {
+        const plan = this.statePlans.get(token);
+        return plan && Object.freeze({ ...plan.report, retired: plan.report.retired || !plan.batch.current() });
+    }
+    closeStateBatch(token) {
+        const batch = this.stateBatches.get(token);
+        if (batch)
+            batch.active = false;
+    }
+    removeOwnedState(owner, id) {
+        const record = this.stateOwners.get(owner), entry = this.entries.get(id);
+        if (!record?.active || !entry || entry.ownedState !== record || record.slots.get(id) !== entry)
+            return false;
+        this.entries.delete(id);
+        record.slots.delete(id);
+        this.forgetSlot(id);
+        return true;
+    }
+    disposeStateOwner(owner) {
+        const record = this.stateOwners.get(owner);
+        if (!record?.active)
+            return;
+        record.active = false;
+        for (const [id, entry] of record.slots)
+            if (this.entries.get(id) === entry) {
+                entry.epoch++;
+                this.advanceSlot(id);
+            }
+        record.slots.clear();
+    }
+    setEvidenceValidator(validator) {
+        this.evidenceValidator = validator;
+    }
+    readIncorporatedSamples(propertyId) {
+        const entry = this.entries.get(propertyId);
+        return entry?.sourceSamples ?? (entry?.sourceSample ? [entry.sourceSample] : null);
+    }
+    captureEvidence(propertyId) {
+        const state = this.read(propertyId);
+        const entry = this.entries.get(propertyId);
+        const sources = this.readIncorporatedSamples(propertyId);
+        if (!entry || !sources?.length || state?.producer.quality !== 'good')
+            return null;
+        return Object.freeze({
+            propertyId,
+            acceptanceGeneration: 0,
+            producer: Object.freeze({
+                lease: entry.lease,
+                publication: entry.publication,
+                revision: entry.lease.revision,
+                expiresAt: Date.parse(state.producer.expiresAt),
+                quality: 'good',
+            }),
+            sources,
+        });
+    }
+    isPublicationCurrent(evidence) {
+        const entry = this.entries.get(evidence.propertyId);
+        return (!!entry &&
+            entry.lease === evidence.producer?.lease &&
+            entry.publication === evidence.producer.publication &&
+            entry.lease.revision === evidence.producer.revision &&
+            entry.guard?.isCurrent() !== false &&
+            entry.state.producer.quality === evidence.producer.quality &&
+            Date.parse(entry.state.producer.evaluatedAt) <= Date.now() &&
+            Date.parse(entry.state.producer.expiresAt) === evidence.producer.expiresAt &&
+            evidence.producer.expiresAt > Date.now());
+    }
+    evidenceCurrent(publication) {
+        if (publication.sourceSample && publication.sourceSamples)
+            return false;
+        const sources = publication.sourceSamples ?? (publication.sourceSample ? [publication.sourceSample] : undefined);
+        return !sources || (!!this.evidenceValidator && this.evidenceValidator(sources));
+    }
+    constructor(events) {
+        this.events = events;
+        this.entries = new Map();
+        this.timer = null;
+        this.publicationSequence = 0;
+        this.stateLifecycle = 0;
+        this.stateOwners = new WeakMap();
+        this.stateBatches = new WeakMap();
+        this.statePlans = new WeakMap();
+        this.slotVersions = new Map();
+        this.removalEpoch = {};
+        this.runtimeSlots = new WeakMap();
+        this.refreshPropertyMetadata = (property) => {
+            const entry = this.entries.get(property.id);
+            if (entry)
+                entry.property = property;
+        };
+    }
+    onModuleInit() {
+        if (this.timer)
+            return;
+        this.events?.on(devices_constants_1.EventType.CHANNEL_PROPERTY_UPDATED, this.refreshPropertyMetadata);
+        this.timer = setInterval(() => this.sweep(), 1_000);
+        this.timer.unref();
+    }
+    onModuleDestroy() {
+        this.stateLifecycle++;
+        if (this.timer)
+            clearInterval(this.timer);
+        this.events?.off(devices_constants_1.EventType.CHANNEL_PROPERTY_UPDATED, this.refreshPropertyMetadata);
+        this.timer = null;
+        this.entries.clear();
+        this.slotVersions.clear();
+        this.removalEpoch = {};
+    }
+    captureRuntimeSlot(propertyId, originalLease) {
+        const previous = this.entries.get(propertyId), lifecycle = this.stateLifecycle;
+        const methods = (0, creation_capture_1.captureCreation)(this, [
+            'captureRuntimeSlot',
+            'registerRuntime',
+            'register',
+            'isAvailable',
+            'isCurrent',
+        ]);
+        const event = this.events && (0, creation_capture_1.captureCreation)(this.events, ['emit']);
+        const emit = this.emit.bind(this);
+        const dispatch = event
+            ? (property) => {
+                event.values.emit.call(event.receiver, devices_constants_1.EventType.CHANNEL_PROPERTY_VALUE_STATE_CHANGED, property);
+            }
+            : null;
+        const token = privateStateToken();
+        this.runtimeSlots.set(token, {
+            id: propertyId,
+            previous,
+            version: this.slotVersions.get(propertyId) ?? 0,
+            removalEpoch: this.removalEpoch,
+            eligible: !previous ||
+                previous.lease === originalLease ||
+                previous.ownedState?.active === true ||
+                previous.retiredByUnregister === true,
+            used: false,
+            current: () => lifecycle === this.stateLifecycle && methods.current() && (!event || event.current()),
+            emit: (property, state) => emit(property, state, dispatch),
+        });
+        return token;
+    }
+    registerRuntime(property, revision, token, guard) {
+        const slot = this.runtimeSlots.get(token);
+        if (!slot || slot.used)
+            return null;
+        slot.used = true;
+        if (!slot.eligible ||
+            !slot.current() ||
+            slot.id !== property.id ||
+            this.entries.get(slot.id) !== slot.previous ||
+            (slot.previous === undefined && slot.removalEpoch !== this.removalEpoch) ||
+            (this.slotVersions.get(slot.id) ?? 0) !== slot.version)
+            return null;
+        if (!Number.isSafeInteger(revision) || revision < 0)
+            throw new Error('Invalid producer revision');
+        const lease = Object.freeze({ propertyId: property.id, revision });
+        const state = this.unavailable(revision, ['initializing'], new Date());
+        this.advanceSlot(property.id);
+        const entry = {
+            property,
+            lease,
+            state,
+            epoch: (slot.previous?.epoch ?? 0) + 1,
+            generation: 0,
+            publication: 0,
+            guard: guard ? Object.freeze({ ...guard }) : undefined,
+        };
+        this.entries.set(property.id, entry);
+        try {
+            slot.emit(property, state);
+        }
+        catch (cause) {
+            if (this.entries.get(property.id) === entry) {
+                if (slot.previous) {
+                    this.entries.set(property.id, slot.previous);
+                    this.advanceSlot(property.id);
+                }
+                else {
+                    this.entries.delete(property.id);
+                    this.forgetSlot(property.id);
+                }
+            }
+            throw cause;
+        }
+        return lease;
+    }
+    register(property, revision, guard) {
+        if (!Number.isSafeInteger(revision) || revision < 0)
+            throw new Error('Invalid producer revision');
+        const lease = Object.freeze({ propertyId: property.id, revision });
+        const previous = this.entries.get(property.id);
+        const state = this.unavailable(revision, ['initializing'], new Date());
+        this.advanceSlot(property.id);
+        this.entries.set(property.id, {
+            property,
+            lease,
+            state,
+            epoch: (previous?.epoch ?? 0) + 1,
+            generation: 0,
+            publication: 0,
+            guard: guard ? Object.freeze({ ...guard }) : undefined,
+        });
+        this.emit(property, state);
+        return lease;
+    }
+    owns(propertyId) {
+        return this.entries.has(propertyId);
+    }
+    isCurrent(lease) {
+        return this.entries.get(lease.propertyId)?.lease === lease;
+    }
+    isAvailable(lease) {
+        const entry = this.entries.get(lease.propertyId);
+        return entry?.lease === lease && (entry.guard?.isCurrent() ?? true);
+    }
+    version(lease) {
+        const entry = this.entries.get(lease.propertyId);
+        return entry?.lease === lease ? entry.epoch : null;
+    }
+    readIncorporatedSample(propertyId) {
+        const entry = this.entries.get(propertyId);
+        return entry && (entry.guard?.isCurrent() ?? true) && entry.state.producer.quality !== 'unavailable'
+            ? (entry?.sourceSample ?? null)
+            : null;
+    }
+    beginEvaluation(lease) {
+        const entry = this.entries.get(lease.propertyId);
+        if (!entry || entry.lease !== lease)
+            return null;
+        return Object.freeze({ epoch: entry.epoch, generation: ++entry.generation });
+    }
+    isEvaluationCurrent(lease, evaluation) {
+        const entry = this.entries.get(lease.propertyId);
+        return (!!entry &&
+            entry.lease === lease &&
+            entry.epoch === evaluation?.epoch &&
+            entry.generation === evaluation?.generation);
+    }
+    canCommit(lease, publication, epoch, generation) {
+        const entry = this.entries.get(lease.propertyId);
+        if (!entry ||
+            entry.guard?.isCurrent() === false ||
+            entry.lease !== lease ||
+            epoch !== entry.epoch ||
+            !['good', 'degraded'].includes(publication.quality) ||
+            !this.evidenceCurrent(publication) ||
+            (generation !== undefined && generation !== entry.generation))
+            return false;
+        const sampled = publication.sampledAt.getTime();
+        const evaluated = publication.evaluatedAt.getTime();
+        const expiry = publication.expiresAt.getTime();
+        return (Number.isFinite(sampled) &&
+            Number.isFinite(evaluated) &&
+            Number.isFinite(expiry) &&
+            sampled <= evaluated &&
+            evaluated <= Date.now() &&
+            expiry > Date.now() &&
+            expiry > evaluated &&
+            evaluated >= Date.parse(entry.state.producer.evaluatedAt));
+    }
+    commit(lease, state, publication, epoch, generation) {
+        if (!this.canCommit(lease, publication, epoch, generation))
+            return false;
+        const entry = this.entries.get(lease.propertyId);
+        const next = (0, property_value_state_model_1.clonePropertyValueState)(state);
+        next.lastUpdated = publication.sampledAt.toISOString();
+        next.producer = Object.assign(new property_value_state_model_1.PropertyProducerState(), {
+            quality: publication.quality,
+            reasons: [...publication.reasons],
+            sampledAt: publication.sampledAt.toISOString(),
+            evaluatedAt: publication.evaluatedAt.toISOString(),
+            expiresAt: publication.expiresAt.toISOString(),
+            revision: lease.revision,
+        });
+        entry.state = next;
+        entry.sourceSample = publication.sourceSample ? Object.freeze({ ...publication.sourceSample }) : undefined;
+        entry.sourceSamples = publication.sourceSamples;
+        entry.publication = ++this.publicationSequence;
+        this.emit(entry.property, next);
+        return true;
+    }
+    invalidate(lease, reasons, evaluatedAt = new Date()) {
+        const entry = this.entries.get(lease.propertyId);
+        if (!entry ||
+            entry.lease !== lease ||
+            !Number.isFinite(evaluatedAt.getTime()) ||
+            evaluatedAt.getTime() > Date.now() ||
+            (evaluatedAt.getTime() < Date.parse(entry.state.producer.evaluatedAt) && entry.guard?.isCurrent() !== false))
+            return false;
+        entry.epoch++;
+        entry.state = this.unavailable(lease.revision, reasons, evaluatedAt);
+        entry.sourceSample = undefined;
+        entry.sourceSamples = undefined;
+        this.emit(entry.property, entry.state);
+        return true;
+    }
+    unregister(lease) {
+        const entry = this.entries.get(lease.propertyId);
+        if (!entry || entry.lease !== lease)
+            return false;
+        this.advanceSlot(lease.propertyId);
+        entry.epoch++;
+        entry.lease = Object.freeze({ propertyId: lease.propertyId, revision: lease.revision });
+        entry.retiredByUnregister = true;
+        entry.state = this.unavailable(lease.revision, ['producer_disposed'], new Date());
+        entry.sourceSample = undefined;
+        entry.sourceSamples = undefined;
+        this.emit(entry.property, entry.state);
+        return true;
+    }
+    remove(propertyId) {
+        this.entries.delete(propertyId);
+        this.forgetSlot(propertyId);
+    }
+    readDiagnosticState(propertyId) {
+        const entry = this.entries.get(propertyId);
+        if (!entry)
+            return null;
+        return entry.guard?.isCurrent() === false || !this.evidenceCurrent(entry)
+            ? this.unavailable(entry.lease.revision, [entry.guard?.reason ?? 'source_changed'], new Date())
+            : (0, property_value_state_model_1.clonePropertyValueState)(entry.state);
+    }
+    read(propertyId) {
+        const entry = this.entries.get(propertyId);
+        if (!entry)
+            return null;
+        if (entry.guard?.isCurrent() === false || !this.evidenceCurrent(entry)) {
+            const state = this.unavailable(entry.lease.revision, [entry.guard?.reason ?? 'source_changed'], new Date());
+            return (0, property_value_state_model_1.clonePropertyValueState)(state);
+        }
+        const now = Date.now();
+        if (entry.state.producer.quality !== 'unavailable' &&
+            (Date.parse(entry.state.producer.evaluatedAt) > now ||
+                (entry.state.producer.sampledAt !== null && Date.parse(entry.state.producer.sampledAt) > now))) {
+            entry.epoch++;
+            entry.state = this.unavailable(entry.lease.revision, ['clock_invalid'], new Date(now));
+            entry.sourceSample = undefined;
+            entry.sourceSamples = undefined;
+            this.emit(entry.property, entry.state);
+        }
+        if (entry.state.producer.quality !== 'unavailable' &&
+            entry.state.producer.expiresAt !== null &&
+            Date.parse(entry.state.producer.expiresAt) <= Date.now())
+            this.invalidate(entry.lease, ['expired']);
+        return (0, property_value_state_model_1.clonePropertyValueState)(entry.state);
+    }
+    sweep() {
+        for (const propertyId of this.entries.keys())
+            this.read(propertyId);
+    }
+    unavailable(revision, reasons, evaluatedAt) {
+        const state = new property_value_state_model_1.PropertyValueState();
+        state.producer = Object.assign(new property_value_state_model_1.PropertyProducerState(), {
+            quality: 'unavailable',
+            reasons: [...reasons],
+            sampledAt: null,
+            evaluatedAt: evaluatedAt.toISOString(),
+            expiresAt: null,
+            revision,
+        });
+        return state;
+    }
+    emit(property, state, dispatch) {
+        const snapshot = Object.assign(Object.create(Object.getPrototypeOf(property)), property);
+        snapshot.value = (0, property_value_state_model_1.clonePropertyValueState)(state);
+        Object.freeze(snapshot.value.producer.reasons);
+        Object.freeze(snapshot.value.producer);
+        Object.freeze(snapshot.value);
+        Object.freeze(snapshot);
+        if (dispatch === undefined)
+            this.events?.emit(devices_constants_1.EventType.CHANNEL_PROPERTY_VALUE_STATE_CHANGED, snapshot);
+        else
+            dispatch?.(snapshot);
+    }
+};
+exports.PropertyProducerRegistryService = PropertyProducerRegistryService;
+exports.PropertyProducerRegistryService = PropertyProducerRegistryService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [event_emitter_1.EventEmitter2])
+], PropertyProducerRegistryService);
+//# sourceMappingURL=property-producer.registry.service.js.map