@nestjslatam/ddd-lib 1.0.51 → 1.0.53

package/dist/core/aggregate/index.d.ts

@@ -0,0 +1,5 @@
+export { AggregateIdentity } from './aggregate-identity';
+export { AggregateEquality } from './aggregate-equality';
+export { AggregateValidationOrchestrator } from './aggregate-validation-orchestrator';
+export { AggregateSerializer } from './aggregate-serializer';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/aggregate/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregateSerializer = exports.AggregateValidationOrchestrator = exports.AggregateEquality = exports.AggregateIdentity = void 0;
+var aggregate_identity_1 = require("./aggregate-identity");
+Object.defineProperty(exports, "AggregateIdentity", { enumerable: true, get: function () { return aggregate_identity_1.AggregateIdentity; } });
+var aggregate_equality_1 = require("./aggregate-equality");
+Object.defineProperty(exports, "AggregateEquality", { enumerable: true, get: function () { return aggregate_equality_1.AggregateEquality; } });
+var aggregate_validation_orchestrator_1 = require("./aggregate-validation-orchestrator");
+Object.defineProperty(exports, "AggregateValidationOrchestrator", { enumerable: true, get: function () { return aggregate_validation_orchestrator_1.AggregateValidationOrchestrator; } });
+var aggregate_serializer_1 = require("./aggregate-serializer");
+Object.defineProperty(exports, "AggregateSerializer", { enumerable: true, get: function () { return aggregate_serializer_1.AggregateSerializer; } });
+//# sourceMappingURL=index.js.map

package/dist/core/business-rules/impl/broken-rule.d.ts

@@ -0,0 +1,7 @@
+export declare class BrokenRule {
+    readonly property: string;
+    readonly message: string;
+    readonly severity: 'Error' | 'Warning';
+    constructor(property: string, message: string, severity: 'Error' | 'Warning');
+}
+//# sourceMappingURL=broken-rule.d.ts.map

package/dist/core/business-rules/impl/broken-rule.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrokenRule = void 0;
+class BrokenRule {
+    constructor(property, message, severity) {
+        this.property = property;
+        this.message = message;
+        this.severity = severity;
+        this.property = property;
+        this.message = message;
+        this.severity = severity;
+    }
+}
+exports.BrokenRule = BrokenRule;
+//# sourceMappingURL=broken-rule.js.map

package/dist/core/business-rules/impl/broken-rules-extension.d.ts

@@ -0,0 +1,6 @@
+import { BrokenRule } from './broken-rule';
+export declare class BrokenRulesExtension {
+    private static readonly BrokenRulesPropertyName;
+    static getPropertiesBrokenRules<T extends object>(instance: T, properties: Array<keyof T>): ReadonlyArray<BrokenRule>;
+}
+//# sourceMappingURL=broken-rules-extension.d.ts.map

package/dist/core/business-rules/impl/broken-rules-extension.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrokenRulesExtension = void 0;
+class BrokenRulesExtension {
+    static getPropertiesBrokenRules(instance, properties) {
+        if (instance === null || instance === undefined) {
+            throw new Error('ArgumentNullException: instance cannot be null or undefined');
+        }
+        if (!properties) {
+            throw new Error('ArgumentNullException: properties cannot be null');
+        }
+        const result = [];
+        for (const key of properties) {
+            const valueObject = instance[key];
+            if (valueObject === null || valueObject === undefined) {
+                continue;
+            }
+            const brokenRulesManager = valueObject[this.BrokenRulesPropertyName];
+            if (brokenRulesManager &&
+                typeof brokenRulesManager.getBrokenRules === 'function') {
+                const brokenRules = brokenRulesManager.getBrokenRules();
+                if (brokenRules.length > 0) {
+                    result.push(...brokenRules);
+                }
+            }
+        }
+        return Object.freeze(result);
+    }
+}
+exports.BrokenRulesExtension = BrokenRulesExtension;
+BrokenRulesExtension.BrokenRulesPropertyName = 'brokenRules';
+//# sourceMappingURL=broken-rules-extension.js.map

package/dist/core/business-rules/impl/index.d.ts

@@ -0,0 +1,4 @@
+export * from './broken-rule';
+export * from './broken-rules-extension';
+export * from './property-change';
+//# sourceMappingURL=index.d.ts.map

package/{ddd-core/broken-rules → dist/core/business-rules/impl}/index.js

@@ -14,6 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./broken-rule-collection"), exports);
 __exportStar(require("./broken-rule"), exports);
+__exportStar(require("./broken-rules-extension"), exports);
+__exportStar(require("./property-change"), exports);
 //# sourceMappingURL=index.js.map

package/dist/core/business-rules/impl/property-change/index.d.ts

@@ -0,0 +1,5 @@
+export * from './notify-property-changed.base';
+export * from './notify-property-changed.context';
+export * from './notify-property-changed.context-args';
+export * from './reflection-type-extensions';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/business-rules/impl/property-change/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./notify-property-changed.base"), exports);
+__exportStar(require("./notify-property-changed.context"), exports);
+__exportStar(require("./notify-property-changed.context-args"), exports);
+__exportStar(require("./reflection-type-extensions"), exports);
+//# sourceMappingURL=index.js.map

package/dist/core/business-rules/impl/property-change/notify-property-changed.base.d.ts

@@ -0,0 +1,16 @@
+import { NotifyPropertyChangedContextArgs } from './notify-property-changed.context-args';
+export type NotifyPropertyChangedHandler = (sender: AbstractNotifyPropertyChanged, e: NotifyPropertyChangedContextArgs) => void;
+export declare abstract class AbstractNotifyPropertyChanged {
+    private readonly properties;
+    protected isCallbackInvokingEnabled: boolean;
+    protected isEventInvokingEnabled: boolean;
+    onPropertyChanged?: (propertyName: string) => void;
+    protected constructor();
+    protected registerProperty(name: string, type: any, defaultValue: any, handler?: NotifyPropertyChangedHandler): void;
+    registerPropertyChangedCallback(propertyName: string, handler: NotifyPropertyChangedHandler): void;
+    protected getValuePropertyChanged(propertyName: string): any;
+    protected setValuePropertyChanged(value: any, propertyName: string, force?: boolean): void;
+    private getPropertyContext;
+    private static validateValueForType;
+}
+//# sourceMappingURL=notify-property-changed.base.d.ts.map

package/dist/core/business-rules/impl/property-change/notify-property-changed.base.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbstractNotifyPropertyChanged = void 0;
+const notify_property_changed_context_1 = require("./notify-property-changed.context");
+const notify_property_changed_context_args_1 = require("./notify-property-changed.context-args");
+const reflection_type_extensions_1 = require("./reflection-type-extensions");
+class AbstractNotifyPropertyChanged {
+    constructor() {
+        this.properties = new Map();
+        this.isCallbackInvokingEnabled = true;
+        this.isEventInvokingEnabled = true;
+    }
+    registerProperty(name, type, defaultValue, handler) {
+        if (this.properties.has(name)) {
+            throw new Error(`This class already contains a registered property called '${name}'.`);
+        }
+        AbstractNotifyPropertyChanged.validateValueForType(defaultValue, type);
+        this.properties.set(name, new notify_property_changed_context_1.NotifyPropertyChangedContext(defaultValue, type, handler));
+    }
+    registerPropertyChangedCallback(propertyName, handler) {
+        const context = this.getPropertyContext(propertyName);
+        context.addCallback(handler);
+    }
+    getValuePropertyChanged(propertyName) {
+        return this.getPropertyContext(propertyName).value;
+    }
+    setValuePropertyChanged(value, propertyName, force = false) {
+        const context = this.getPropertyContext(propertyName);
+        AbstractNotifyPropertyChanged.validateValueForType(value, context.type);
+        const oldValue = context.value;
+        const valuesEqual = oldValue === value;
+        if (force || !valuesEqual) {
+            context.value = value;
+            if (this.isCallbackInvokingEnabled) {
+                context.invokePropertyChangedCallback(this, new notify_property_changed_context_args_1.NotifyPropertyChangedContextArgs(oldValue, value));
+            }
+            if (this.isEventInvokingEnabled && this.onPropertyChanged) {
+                this.onPropertyChanged(propertyName);
+            }
+        }
+    }
+    getPropertyContext(propertyName) {
+        const context = this.properties.get(propertyName);
+        if (!context) {
+            throw new Error(`No hay una propiedad registrada llamada '${propertyName}'.`);
+        }
+        return context;
+    }
+    static validateValueForType(value, type) {
+        if (value === null || value === undefined) {
+            const isValueType = reflection_type_extensions_1.ReflectionTypeExtensions.getIsValueType(type);
+            if (isValueType) {
+                throw new Error(`El tipo '${type.name || type}' no es un tipo nulable.`);
+            }
+            return;
+        }
+        const sourceType = value.constructor;
+        if (!reflection_type_extensions_1.ReflectionTypeExtensions.getIsAssignableFrom(type, sourceType)) {
+            throw new Error(`El valor especificado no se puede asignar a una propiedad de tipo (${type.name || type})`);
+        }
+    }
+}
+exports.AbstractNotifyPropertyChanged = AbstractNotifyPropertyChanged;
+//# sourceMappingURL=notify-property-changed.base.js.map

package/dist/core/business-rules/impl/property-change/notify-property-changed.context-args.d.ts

@@ -0,0 +1,7 @@
+export declare class NotifyPropertyChangedContextArgs {
+    readonly previousValue: any;
+    readonly newValue: any;
+    handled: boolean;
+    constructor(previousValue: any, newValue: any);
+}
+//# sourceMappingURL=notify-property-changed.context-args.d.ts.map

package/dist/core/business-rules/impl/property-change/notify-property-changed.context-args.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotifyPropertyChangedContextArgs = void 0;
+class NotifyPropertyChangedContextArgs {
+    constructor(previousValue, newValue) {
+        this.previousValue = previousValue;
+        this.newValue = newValue;
+        this.handled = false;
+    }
+}
+exports.NotifyPropertyChangedContextArgs = NotifyPropertyChangedContextArgs;
+//# sourceMappingURL=notify-property-changed.context-args.js.map

package/dist/core/business-rules/impl/property-change/notify-property-changed.context.d.ts

@@ -0,0 +1,11 @@
+import { NotifyPropertyChangedContextArgs } from './notify-property-changed.context-args';
+import { AbstractNotifyPropertyChanged, NotifyPropertyChangedHandler } from './notify-property-changed.base';
+export declare class NotifyPropertyChangedContext {
+    value: any;
+    readonly type: any;
+    private readonly callbacks;
+    constructor(defaultValue: any, type: any, handler?: NotifyPropertyChangedHandler);
+    addCallback(handler: NotifyPropertyChangedHandler): void;
+    invokePropertyChangedCallback(sender: AbstractNotifyPropertyChanged, e: NotifyPropertyChangedContextArgs): void;
+}
+//# sourceMappingURL=notify-property-changed.context.d.ts.map

package/dist/core/business-rules/impl/property-change/notify-property-changed.context.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotifyPropertyChangedContext = void 0;
+class NotifyPropertyChangedContext {
+    constructor(defaultValue, type, handler) {
+        this.callbacks = new Set();
+        this.value = defaultValue;
+        this.type = type;
+        if (handler) {
+            this.callbacks.add(handler);
+        }
+    }
+    addCallback(handler) {
+        this.callbacks.add(handler);
+    }
+    invokePropertyChangedCallback(sender, e) {
+        this.callbacks.forEach((callback) => callback(sender, e));
+    }
+}
+exports.NotifyPropertyChangedContext = NotifyPropertyChangedContext;
+//# sourceMappingURL=notify-property-changed.context.js.map

package/dist/core/business-rules/impl/property-change/reflection-type-extensions.d.ts

@@ -0,0 +1,5 @@
+export declare class ReflectionTypeExtensions {
+    static getIsValueType(type: any): boolean;
+    static getIsAssignableFrom(targetType: any, sourceType: any): boolean;
+}
+//# sourceMappingURL=reflection-type-extensions.d.ts.map

package/dist/core/business-rules/impl/property-change/reflection-type-extensions.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReflectionTypeExtensions = void 0;
+class ReflectionTypeExtensions {
+    static getIsValueType(type) {
+        if (!type)
+            return false;
+        const valueTypes = [String, Number, Boolean, Symbol, BigInt];
+        return valueTypes.includes(type);
+    }
+    static getIsAssignableFrom(targetType, sourceType) {
+        if (!targetType || !sourceType)
+            return false;
+        if (targetType === sourceType)
+            return true;
+        if (typeof sourceType === 'function' && typeof targetType === 'function') {
+            return sourceType.prototype instanceof targetType;
+        }
+        return false;
+    }
+}
+exports.ReflectionTypeExtensions = ReflectionTypeExtensions;
+//# sourceMappingURL=reflection-type-extensions.js.map

package/dist/core/business-rules/index.d.ts

@@ -0,0 +1,2 @@
+export * from './impl';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts

@@ -0,0 +1,6 @@
+export * from './tracking-state';
+export * from './validator-rules';
+export * from './business-rules';
+export * from './repositories';
+export * from './aggregate';
+//# sourceMappingURL=index.d.ts.map

package/{ddd-core → dist/core}/index.js

@@ -14,9 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./broken-rules"), exports);
-__exportStar(require("./interfaces"), exports);
-__exportStar(require("../ddd-validators"), exports);
-__exportStar(require("../ddd-validators"), exports);
-__exportStar(require("./impl"), exports);
+__exportStar(require("./tracking-state"), exports);
+__exportStar(require("./validator-rules"), exports);
+__exportStar(require("./business-rules"), exports);
+__exportStar(require("./repositories"), exports);
+__exportStar(require("./aggregate"), exports);
 //# sourceMappingURL=index.js.map

package/dist/core/repositories/index.d.ts

@@ -0,0 +1,3 @@
+export * from './repository-read.interface';
+export * from './repository-write.interface';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/repositories/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./repository-read.interface"), exports);
+__exportStar(require("./repository-write.interface"), exports);
+//# sourceMappingURL=index.js.map

package/dist/core/repositories/repository-read.interface.d.ts

@@ -0,0 +1,7 @@
+import { DddAggregateRoot } from "../../aggregate-root";
+import { Primitives } from "../tracking-state";
+export interface IDomainReadRepository<TKey extends Primitives, TDomain extends DddAggregateRoot<any, any>> {
+    find(): Promise<TDomain[]>;
+    findById(id: TKey): Promise<TDomain>;
+}
+//# sourceMappingURL=repository-read.interface.d.ts.map

package/{ddd-commands/interfaces/command-handler.interface.js → dist/core/repositories/repository-read.interface.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=command-handler.interface.js.map
+//# sourceMappingURL=repository-read.interface.js.map

package/{ddd-ports/interfaces/domain-repository-write.interface.d.ts → dist/core/repositories/repository-write.interface.d.ts}

@@ -1,8 +1,9 @@
-import { DomainAggregateRoot } from '../../ddd-aggregate-root';
-import { DomainEntity, Primitives } from '../../ddd-core/ddd-base-classes';
-export interface IDomainWriteRepository<TKey extends Primitives, TDomain extends DomainAggregateRoot<any> | DomainEntity<any>> {
+import { DddAggregateRoot } from "../../aggregate-root";
+import { Primitives } from "../tracking-state";
+export interface IDomainWriteRepository<TKey extends Primitives, TDomain extends DddAggregateRoot<any, any>> {
     insert(entity: TDomain): Promise<void>;
     insertBatch(entities: TDomain[]): Promise<void>;
     update(id: TKey, entity: TDomain): Promise<void>;
     delete(id: TKey): Promise<void>;
 }
+//# sourceMappingURL=repository-write.interface.d.ts.map

package/{ddd-commands/interfaces/command-metadata.interface.js → dist/core/repositories/repository-write.interface.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=command-metadata.interface.js.map
+//# sourceMappingURL=repository-write.interface.js.map

package/dist/core/tracking-state/impl/index.d.ts

@@ -0,0 +1,4 @@
+export * from './tracking-props';
+export * from './nested-property-change-detector';
+export * from './tracking-state-transition';
+//# sourceMappingURL=index.d.ts.map

package/{ddd-core → dist/core/tracking-state}/impl/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./observable-bus"), exports);
-__exportStar(require("./of-type"), exports);
 __exportStar(require("./tracking-props"), exports);
+__exportStar(require("./nested-property-change-detector"), exports);
+__exportStar(require("./tracking-state-transition"), exports);
 //# sourceMappingURL=index.js.map

package/dist/core/tracking-state/impl/nested-property-change-detector.d.ts

@@ -0,0 +1,8 @@
+import { IChangeDetector, ITrackingStateManager } from '../interfaces';
+export declare class NestedPropertyChangeDetector implements IChangeDetector {
+    private static readonly TrackingKeyName;
+    private validateProps;
+    private processTrackingValue;
+    detectChanges<TProp>(props: TProp, trackingStateManager: ITrackingStateManager): ITrackingStateManager;
+}
+//# sourceMappingURL=nested-property-change-detector.d.ts.map

package/dist/core/tracking-state/impl/nested-property-change-detector.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestedPropertyChangeDetector = void 0;
+class NestedPropertyChangeDetector {
+    validateProps(props) {
+        if (!props) {
+            throw new Error('ArgumentNullException: props cannot be null');
+        }
+    }
+    processTrackingValue(value, trackingStateManager) {
+        if (value === null || typeof value !== 'object') {
+            return;
+        }
+        const trackingValue = value[NestedPropertyChangeDetector.TrackingKeyName];
+        if (!trackingValue) {
+            return;
+        }
+        if (trackingValue.isDirty)
+            trackingStateManager.markAsDirty();
+        if (trackingValue.isNew)
+            trackingStateManager.markAsNew();
+        if (trackingValue.isSelfDeleted)
+            trackingStateManager.markAsSelfDeleted();
+        if (trackingValue.isDeleted)
+            trackingStateManager.markAsDeleted();
+    }
+    detectChanges(props, trackingStateManager) {
+        this.validateProps(props);
+        trackingStateManager.markAsClean();
+        Object.keys(props).forEach((key) => {
+            this.processTrackingValue(props[key], trackingStateManager);
+        });
+        return trackingStateManager;
+    }
+}
+exports.NestedPropertyChangeDetector = NestedPropertyChangeDetector;
+NestedPropertyChangeDetector.TrackingKeyName = 'Tracking';
+//# sourceMappingURL=nested-property-change-detector.js.map

package/{ddd-core → dist/core/tracking-state}/impl/tracking-props.d.ts

@@ -3,7 +3,10 @@ export declare class TrackingProps implements ITrackingProps {
     isDirty: boolean;
     isNew: boolean;
     isDeleted: boolean;
+    isSelfDeleted: boolean;
     static setNew(): TrackingProps;
     static setDirty(): TrackingProps;
     static setDeleted(): TrackingProps;
+    static setSelfDeleted(): TrackingProps;
 }
+//# sourceMappingURL=tracking-props.d.ts.map

package/{ddd-core → dist/core/tracking-state}/impl/tracking-props.js

@@ -7,6 +7,7 @@ class TrackingProps {
             isDirty: false,
             isNew: true,
             isDeleted: false,
+            isSelfDeleted: false,
         };
     }
     static setDirty() {
@@ -14,6 +15,7 @@ class TrackingProps {
             isDirty: true,
             isNew: false,
             isDeleted: false,
+            isSelfDeleted: false,
         };
     }
     static setDeleted() {
@@ -21,6 +23,15 @@ class TrackingProps {
             isDirty: false,
             isNew: false,
             isDeleted: true,
+            isSelfDeleted: false,
+        };
+    }
+    static setSelfDeleted() {
+        return {
+            isDirty: false,
+            isNew: false,
+            isDeleted: false,
+            isSelfDeleted: true,
         };
     }
 }

package/dist/core/tracking-state/impl/tracking-state-transition.d.ts

@@ -0,0 +1,9 @@
+import { ITrackingStateTransitions } from '../interfaces/itracking-state-transitions';
+export declare class TrackingStateTransition {
+    private static applyTransition;
+    static toDirty(manager: ITrackingStateTransitions): void;
+    static toNew(manager: ITrackingStateTransitions): void;
+    static toSelfDeleted(manager: ITrackingStateTransitions): void;
+    static toDeleted(manager: ITrackingStateTransitions): void;
+}
+//# sourceMappingURL=tracking-state-transition.d.ts.map

package/dist/core/tracking-state/impl/tracking-state-transition.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrackingStateTransition = void 0;
+class TrackingStateTransition {
+    static applyTransition(manager, stateUpdate) {
+        manager.setDirty(false);
+        manager.setNew(false);
+        manager.setSelfDeleted(false);
+        manager.setDeleted(false);
+        stateUpdate(manager);
+    }
+    static toDirty(manager) {
+        this.applyTransition(manager, (m) => {
+            m.setDirty(true);
+        });
+    }
+    static toNew(manager) {
+        this.applyTransition(manager, (m) => {
+            m.setNew(true);
+        });
+    }
+    static toSelfDeleted(manager) {
+        this.applyTransition(manager, (m) => {
+            m.setSelfDeleted(true);
+        });
+    }
+    static toDeleted(manager) {
+        this.applyTransition(manager, (m) => {
+            m.setDeleted(true);
+        });
+    }
+}
+exports.TrackingStateTransition = TrackingStateTransition;
+//# sourceMappingURL=tracking-state-transition.js.map

package/{ddd-commands → dist/core/tracking-state}/index.d.ts

@@ -1,2 +1,3 @@
 export * from './interfaces';
 export * from './impl';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/tracking-state/interfaces/ichange-detector.d.ts

@@ -0,0 +1,8 @@
+import { ITrackingStateManager } from './itracking-state-manager';
+export interface IProps {
+    [key: string]: any;
+}
+export interface IChangeDetector {
+    detectChanges<TProp extends IProps>(props: TProp, trackingStateManager: ITrackingStateManager): ITrackingStateManager;
+}
+//# sourceMappingURL=ichange-detector.d.ts.map

package/{ddd-commands/interfaces/command.interface.js → dist/core/tracking-state/interfaces/ichange-detector.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=command.interface.js.map
+//# sourceMappingURL=ichange-detector.js.map

package/dist/core/tracking-state/interfaces/idomain-primitive.d.ts

@@ -0,0 +1,5 @@
+export type Primitives = string | number | boolean | Date;
+export interface IDddPrimitive<T> {
+    value: T;
+}
+//# sourceMappingURL=idomain-primitive.d.ts.map

package/dist/core/tracking-state/interfaces/idomain-primitive.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=idomain-primitive.js.map

package/dist/core/tracking-state/interfaces/index.d.ts

@@ -0,0 +1,6 @@
+export * from './itracking-props';
+export * from './idomain-primitive';
+export * from './itracking-state-manager';
+export * from './itracking-state-transitions';
+export * from './ichange-detector';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/tracking-state/interfaces/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./itracking-props"), exports);
+__exportStar(require("./idomain-primitive"), exports);
+__exportStar(require("./itracking-state-manager"), exports);
+__exportStar(require("./itracking-state-transitions"), exports);
+__exportStar(require("./ichange-detector"), exports);
+//# sourceMappingURL=index.js.map

package/{ddd-core/interfaces/tracking.interface.d.ts → dist/core/tracking-state/interfaces/itracking-props.d.ts}

@@ -2,4 +2,6 @@ export interface ITrackingProps {
     isDirty: boolean;
     isNew: boolean;
     isDeleted: boolean;
+    isSelfDeleted: boolean;
 }
+//# sourceMappingURL=itracking-props.d.ts.map

package/{ddd-core/interfaces/saga.interface.js → dist/core/tracking-state/interfaces/itracking-props.js}

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=saga.interface.js.map
+//# sourceMappingURL=itracking-props.js.map