json-diff-ts 3.0.0-beta.1 → 3.0.0-beta.2

package/{lib/jsonDiff.d.ts → dist/index.d.cts}

@@ -1,12 +1,12 @@
 type FunctionKey = (obj: any, shouldReturnKeyName?: boolean) => any;
-export type EmbeddedObjKeysType = Record<string, string | FunctionKey>;
-export type EmbeddedObjKeysMapType = Map<string | RegExp, string | FunctionKey>;
-export declare enum Operation {
+type EmbeddedObjKeysType = Record<string, string | FunctionKey>;
+type EmbeddedObjKeysMapType = Map<string | RegExp, string | FunctionKey>;
+declare enum Operation {
     REMOVE = "REMOVE",
     ADD = "ADD",
     UPDATE = "UPDATE"
 }
-export interface IChange {
+interface IChange {
     type: Operation;
     key: string;
     embeddedKey?: string | FunctionKey;
@@ -14,8 +14,8 @@ export interface IChange {
     oldValue?: any;
     changes?: IChange[];
 }
-export type Changeset = IChange[];
-export interface IFlatChange {
+type Changeset = IChange[];
+interface IFlatChange {
     type: Operation;
     key: string;
     path: string;
@@ -31,7 +31,7 @@ export interface IFlatChange {
  * @param {EmbeddedObjKeysType | EmbeddedObjKeysMapType} embeddedObjKeys - An optional parameter specifying keys of embedded objects.
  * @returns {IChange[]} - An array of changes that transform the old object into the new object.
  */
-export declare function diff(oldObj: any, newObj: any, embeddedObjKeys?: EmbeddedObjKeysType | EmbeddedObjKeysMapType, keysToSkip?: string[]): IChange[];
+declare function diff(oldObj: any, newObj: any, embeddedObjKeys?: EmbeddedObjKeysType | EmbeddedObjKeysMapType, keysToSkip?: string[]): IChange[];
 /**
  * Applies all changes in the changeset to the object.
  *
@@ -43,7 +43,7 @@ export declare function diff(oldObj: any, newObj: any, embeddedObjKeys?: Embedde
  * If the change value is not null or undefined, or if the change type is REMOVE, it applies the change to the object directly.
  * Otherwise, it applies the change to the corresponding branch of the object.
  */
-export declare const applyChangeset: (obj: any, changeset: Changeset) => any;
+declare const applyChangeset: (obj: any, changeset: Changeset) => any;
 /**
  * Reverts the changes made to an object based on a given changeset.
  *
@@ -55,7 +55,7 @@ export declare const applyChangeset: (obj: any, changeset: Changeset) => any;
  * It then iterates over each change in the changeset. If the change does not have any nested changes, it reverts the change on the object directly.
  * If the change does have nested changes, it reverts the changes on the corresponding branch of the object.
  */
-export declare const revertChangeset: (obj: any, changeset: Changeset) => any;
+declare const revertChangeset: (obj: any, changeset: Changeset) => any;
 /**
  * Flattens a changeset into an array of flat changes.
  *
@@ -69,7 +69,7 @@ export declare const revertChangeset: (obj: any, changeset: Changeset) => any;
  * If so, it updates the path and recursively flattens the nested changes or the embedded object.
  * If the change does not have nested changes or an embedded key, it creates a flat change and returns it in an array.
  */
-export declare const flattenChangeset: (obj: Changeset | IChange, path?: string, embeddedKey?: string | FunctionKey) => IFlatChange[];
+declare const flattenChangeset: (obj: Changeset | IChange, path?: string, embeddedKey?: string | FunctionKey) => IFlatChange[];
 /**
  * Transforms a flat changeset into a nested changeset.
  *
@@ -83,7 +83,7 @@ export declare const flattenChangeset: (obj: Changeset | IChange, path?: string,
  * If it represents a leaf node, it sets the key, type, value, and oldValue of the current change object.
  * Finally, it pushes the unflattened change object into the changes array.
  */
-export declare const unflattenChanges: (changes: IFlatChange | IFlatChange[]) => IChange[];
+declare const unflattenChanges: (changes: IFlatChange | IFlatChange[]) => IChange[];
 /**
  * Determines the type of a given object.
  *
@@ -94,5 +94,22 @@ export declare const unflattenChanges: (changes: IFlatChange | IFlatChange[]) =>
  * If the object is neither undefined nor null, it uses Object.prototype.toString to get the object's type.
  * The type is extracted from the string returned by Object.prototype.toString using a regular expression.
  */
-export declare const getTypeOfObj: (obj: any) => string;
-export {};
+declare const getTypeOfObj: (obj: any) => string;
+
+declare enum CompareOperation {
+    CONTAINER = "CONTAINER",
+    UNCHANGED = "UNCHANGED"
+}
+interface IComparisonEnrichedNode {
+    type: Operation | CompareOperation;
+    value: IComparisonEnrichedNode | IComparisonEnrichedNode[] | any | any[];
+    oldValue?: any;
+}
+declare const createValue: (value: any) => IComparisonEnrichedNode;
+declare const createContainer: (value: object | [
+]) => IComparisonEnrichedNode;
+declare const enrich: (object: any) => IComparisonEnrichedNode;
+declare const applyChangelist: (object: IComparisonEnrichedNode, changelist: IFlatChange[]) => IComparisonEnrichedNode;
+declare const compare: (oldObject: any, newObject: any) => IComparisonEnrichedNode;
+
+export { type Changeset, CompareOperation, type EmbeddedObjKeysMapType, type EmbeddedObjKeysType, type IChange, type IComparisonEnrichedNode, type IFlatChange, Operation, applyChangelist, applyChangeset, compare, createContainer, createValue, diff, enrich, flattenChangeset, getTypeOfObj, revertChangeset, unflattenChanges };

package/dist/index.d.ts

@@ -0,0 +1,115 @@
+type FunctionKey = (obj: any, shouldReturnKeyName?: boolean) => any;
+type EmbeddedObjKeysType = Record<string, string | FunctionKey>;
+type EmbeddedObjKeysMapType = Map<string | RegExp, string | FunctionKey>;
+declare enum Operation {
+    REMOVE = "REMOVE",
+    ADD = "ADD",
+    UPDATE = "UPDATE"
+}
+interface IChange {
+    type: Operation;
+    key: string;
+    embeddedKey?: string | FunctionKey;
+    value?: any | any[];
+    oldValue?: any;
+    changes?: IChange[];
+}
+type Changeset = IChange[];
+interface IFlatChange {
+    type: Operation;
+    key: string;
+    path: string;
+    valueType: string | null;
+    value?: any;
+    oldValue?: any;
+}
+/**
+ * Computes the difference between two objects.
+ *
+ * @param {any} oldObj - The original object.
+ * @param {any} newObj - The updated object.
+ * @param {EmbeddedObjKeysType | EmbeddedObjKeysMapType} embeddedObjKeys - An optional parameter specifying keys of embedded objects.
+ * @returns {IChange[]} - An array of changes that transform the old object into the new object.
+ */
+declare function diff(oldObj: any, newObj: any, embeddedObjKeys?: EmbeddedObjKeysType | EmbeddedObjKeysMapType, keysToSkip?: string[]): IChange[];
+/**
+ * Applies all changes in the changeset to the object.
+ *
+ * @param {any} obj - The object to apply changes to.
+ * @param {Changeset} changeset - The changeset to apply.
+ * @returns {any} - The object after the changes from the changeset have been applied.
+ *
+ * The function first checks if a changeset is provided. If so, it iterates over each change in the changeset.
+ * If the change value is not null or undefined, or if the change type is REMOVE, it applies the change to the object directly.
+ * Otherwise, it applies the change to the corresponding branch of the object.
+ */
+declare const applyChangeset: (obj: any, changeset: Changeset) => any;
+/**
+ * Reverts the changes made to an object based on a given changeset.
+ *
+ * @param {any} obj - The object on which to revert changes.
+ * @param {Changeset} changeset - The changeset to revert.
+ * @returns {any} - The object after the changes from the changeset have been reverted.
+ *
+ * The function first checks if a changeset is provided. If so, it reverses the changeset to start reverting from the last change.
+ * It then iterates over each change in the changeset. If the change does not have any nested changes, it reverts the change on the object directly.
+ * If the change does have nested changes, it reverts the changes on the corresponding branch of the object.
+ */
+declare const revertChangeset: (obj: any, changeset: Changeset) => any;
+/**
+ * Flattens a changeset into an array of flat changes.
+ *
+ * @param {Changeset | IChange} obj - The changeset or change to flatten.
+ * @param {string} [path='$'] - The current path in the changeset.
+ * @param {string | FunctionKey} [embeddedKey] - The key to use for embedded objects.
+ * @returns {IFlatChange[]} - An array of flat changes.
+ *
+ * The function first checks if the input is an array. If so, it recursively flattens each change in the array.
+ * If the input is not an array, it checks if the change has nested changes or an embedded key.
+ * If so, it updates the path and recursively flattens the nested changes or the embedded object.
+ * If the change does not have nested changes or an embedded key, it creates a flat change and returns it in an array.
+ */
+declare const flattenChangeset: (obj: Changeset | IChange, path?: string, embeddedKey?: string | FunctionKey) => IFlatChange[];
+/**
+ * Transforms a flat changeset into a nested changeset.
+ *
+ * @param {IFlatChange | IFlatChange[]} changes - The flat changeset to unflatten.
+ * @returns {IChange[]} - The unflattened changeset.
+ *
+ * The function first checks if the input is a single change or an array of changes.
+ * It then iterates over each change and splits its path into segments.
+ * For each segment, it checks if it represents an array or a leaf node.
+ * If it represents an array, it creates a new change object and updates the pointer to this new object.
+ * If it represents a leaf node, it sets the key, type, value, and oldValue of the current change object.
+ * Finally, it pushes the unflattened change object into the changes array.
+ */
+declare const unflattenChanges: (changes: IFlatChange | IFlatChange[]) => IChange[];
+/**
+ * Determines the type of a given object.
+ *
+ * @param {any} obj - The object whose type is to be determined.
+ * @returns {string | null} - The type of the object, or null if the object is null.
+ *
+ * This function first checks if the object is undefined or null, and returns 'undefined' or null respectively.
+ * If the object is neither undefined nor null, it uses Object.prototype.toString to get the object's type.
+ * The type is extracted from the string returned by Object.prototype.toString using a regular expression.
+ */
+declare const getTypeOfObj: (obj: any) => string;
+
+declare enum CompareOperation {
+    CONTAINER = "CONTAINER",
+    UNCHANGED = "UNCHANGED"
+}
+interface IComparisonEnrichedNode {
+    type: Operation | CompareOperation;
+    value: IComparisonEnrichedNode | IComparisonEnrichedNode[] | any | any[];
+    oldValue?: any;
+}
+declare const createValue: (value: any) => IComparisonEnrichedNode;
+declare const createContainer: (value: object | [
+]) => IComparisonEnrichedNode;
+declare const enrich: (object: any) => IComparisonEnrichedNode;
+declare const applyChangelist: (object: IComparisonEnrichedNode, changelist: IFlatChange[]) => IComparisonEnrichedNode;
+declare const compare: (oldObject: any, newObject: any) => IComparisonEnrichedNode;
+
+export { type Changeset, CompareOperation, type EmbeddedObjKeysMapType, type EmbeddedObjKeysType, type IChange, type IComparisonEnrichedNode, type IFlatChange, Operation, applyChangelist, applyChangeset, compare, createContainer, createValue, diff, enrich, flattenChangeset, getTypeOfObj, revertChangeset, unflattenChanges };