ts-serializable 4.2.2 → 4.3.2

package/dist/functions/DeserializeProperty.js

@@ -0,0 +1,142 @@
+import { Serializable } from "../classes/Serializable.js";
+import { fromJSON } from "./FromJSON.js";
+import { onWrongType } from "./OnWrongType.js";
+/**
+ * Deserializes a single property value from JSON data based on accepted type definitions.
+ * This function iterates through accepted types and attempts to match and convert the JSON value
+ * to the appropriate TypeScript type. Supports primitives, arrays, dates, and complex object types.
+ *
+ * @param {object} obj - The object instance to which the property belongs
+ * @param {string} prop - The name of the property being deserialized
+ * @param {AcceptedTypes[]} acceptedTypes - Array of type constructors or type definitions that the property can accept
+ * @param {unknown} jsonValue - The raw JSON value to deserialize and convert
+ * @param {Partial<SerializationSettings>} [settings] - Optional settings to customize deserialization behavior
+ * @returns {unknown} The deserialized and typed value, or the original property value if no type match is found
+ *
+ * @remarks
+ * Supported type conversions:
+ * - `null` - Preserves null values
+ * - `undefined` (void 0) - For deep copy operations
+ * - `Boolean` - Converts boolean values and Boolean objects
+ * - `Number` - Converts numeric values and Number objects
+ * - `String` - Converts string values and String objects
+ * - `Object` - Converts plain objects
+ * - `Date` - Parses ISO strings, Date objects, and validates date values
+ * - `Array` - Recursively deserializes array elements
+ * - `Serializable` subclasses - Creates instances and calls fromJSON
+ * - Custom classes - Creates instances and applies fromJSON for non-Serializable classes
+ * - Instance checks - Validates existing instances of specific classes
+ *
+ * If no type matches, calls `onWrongType` error handler and returns the original property value.
+ *
+ * @example
+ * ```typescript
+ * const acceptedTypes = [String, Number];
+ * const result = deserializeProperty(obj, "age", acceptedTypes, "30");
+ * // Returns the string "30" since String is checked first
+ * ```
+ */
+// eslint-disable-next-line max-lines-per-function, max-statements, complexity
+export const deserializeProperty = (obj, prop, acceptedTypes, jsonValue, settings
+// eslint-disable-next-line max-params
+) => {
+    for (const acceptedType of acceptedTypes) { // Type Symbol is not a property
+        if ( // Null
+        acceptedType === null &&
+            jsonValue === null) {
+            return null;
+        }
+        else if ( // Void, for deep copy classes only, JSON doesn't have a void type
+        acceptedType === void 0 &&
+            jsonValue === void 0) {
+            return void 0;
+        }
+        else if ( // Boolean, Boolean
+        acceptedType === Boolean &&
+            (typeof jsonValue === "boolean" || jsonValue instanceof Boolean)) {
+            return Boolean(jsonValue);
+        }
+        else if ( // Number, Number
+        acceptedType === Number &&
+            (typeof jsonValue === "number" || jsonValue instanceof Number)) {
+            return Number(jsonValue);
+        }
+        else if ( // String, String
+        acceptedType === String &&
+            (typeof jsonValue === "string" || jsonValue instanceof String)) {
+            return String(jsonValue);
+        }
+        else if ( // Object, Object
+        acceptedType === Object &&
+            (typeof jsonValue === "object")) {
+            return Object(jsonValue);
+        }
+        else if ( // Date
+        acceptedType === Date &&
+            (typeof jsonValue === "string" || jsonValue instanceof String || jsonValue instanceof Date)) {
+            // 0 year, 0 month, 0 days, 0 hours, 0 minutes, 0 seconds
+            let unicodeTime = new Date("0000-01-01T00:00:00.000").getTime();
+            if (typeof jsonValue === "string") {
+                unicodeTime = Date.parse(jsonValue);
+            }
+            else if (jsonValue instanceof String) {
+                unicodeTime = Date.parse(String(jsonValue));
+            }
+            else if (jsonValue instanceof Date) {
+                unicodeTime = jsonValue.getTime();
+            }
+            if (isNaN(unicodeTime)) { // Preserve invalid time
+                if (obj instanceof Serializable) {
+                    obj.onWrongType(prop, "is an invalid date", jsonValue);
+                }
+                else {
+                    onWrongType(obj, prop, "is an invalid date", jsonValue);
+                }
+            }
+            return new Date(unicodeTime);
+        }
+        else if ( // Array
+        Array.isArray(acceptedType) &&
+            Array.isArray(jsonValue)) {
+            if (acceptedType[0] === void 0) {
+                if (obj instanceof Serializable) {
+                    obj.onWrongType(prop, "invalid type", jsonValue);
+                }
+                else {
+                    onWrongType(obj, prop, "invalid type", jsonValue);
+                }
+            }
+            return jsonValue.map((arrayValue) => deserializeProperty(obj, prop, acceptedType, arrayValue, settings));
+        }
+        else if ( // Serializable
+        acceptedType !== null &&
+            acceptedType !== void 0 &&
+            !Array.isArray(acceptedType) &&
+            (acceptedType.prototype instanceof Serializable ||
+                acceptedType instanceof Function) &&
+            jsonValue !== null &&
+            jsonValue !== void 0 &&
+            typeof jsonValue === "object" && !Array.isArray(jsonValue)) {
+            if (acceptedType.prototype instanceof Serializable) {
+                const TypeConstructor = acceptedType;
+                return new TypeConstructor().fromJSON(jsonValue, settings);
+            }
+            // Class without Serializable base class
+            const TypeConstructor = acceptedType;
+            return fromJSON(new TypeConstructor(), jsonValue, settings);
+        }
+        else if ( // Instance any other class, not Serializable, for parsing from other class instances
+        acceptedType instanceof Function &&
+            jsonValue instanceof acceptedType) {
+            return jsonValue;
+        }
+    }
+    // Process incorrect type and return default value
+    if (obj instanceof Serializable) {
+        obj.onWrongType(prop, "is invalid", jsonValue);
+    }
+    else {
+        onWrongType(obj, prop, "is invalid", jsonValue);
+    }
+    return Reflect.get(obj, prop);
+};

package/dist/functions/FromJSON.d.ts

@@ -0,0 +1,56 @@
+import { Serializable } from "../classes/Serializable.js";
+import { SerializationSettings } from "../models/SerializationSettings.js";
+/**
+ * Deserializes JSON data into an existing object instance, populating its properties.
+ * This function reads metadata from @JsonProperty decorators to determine property types
+ * and performs appropriate type conversions. It supports both Serializable and plain object instances.
+ *
+ * @template T - The type of object being deserialized (extends Serializable or plain object)
+ * @param {T} obj - The target object instance to populate with deserialized data
+ * @param {object} json - The JSON object containing source data for deserialization
+ * @param {Partial<SerializationSettings>} [settings] - Optional settings to customize deserialization behavior
+ * @returns {T} The same object instance with properties populated from JSON
+ *
+ * @remarks
+ * The function performs the following steps:
+ * 1. Validates that json is an object (not null, array, or primitive)
+ * 2. Iterates through all properties of the target object
+ * 3. Resolves JSON property names using @JsonName decorators and naming strategies
+ * 4. Falls back to original property names for deep copy operations
+ * 5. Deserializes each property value according to its type metadata
+ * 6. Calls error handlers for invalid or missing data
+ *
+ * Property name resolution priority:
+ * - @JsonName decorator value
+ * - Naming strategy transformation (snake_case, camelCase, etc.)
+ * - Original property name (fallback for deep copy)
+ *
+ * @example
+ * ```typescript
+ * class User extends Serializable {
+ *   @JsonProperty(String)
+ *   name: string;
+ *
+ *   @JsonProperty(Number)
+ *   age: number;
+ * }
+ *
+ * const user = new User();
+ * fromJSON(user, { name: "John", age: 30 });
+ * console.log(user.name); // "John"
+ * console.log(user.age);  // 30
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using with plain objects (non-Serializable)
+ * class Product {
+ *   @JsonProperty(String)
+ *   title: string;
+ * }
+ *
+ * const product = new Product();
+ * fromJSON(product, { title: "Laptop" });
+ * ```
+ */
+export declare const fromJSON: <T extends (Serializable | object)>(obj: T, json: object, settings?: Partial<SerializationSettings>) => T;

package/dist/functions/FromJSON.js

@@ -0,0 +1,97 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable no-prototype-builtins */
+/* eslint-disable @typescript-eslint/no-unnecessary-condition */
+import { Serializable } from "../classes/Serializable.js";
+import { deserializeProperty } from "./DeserializeProperty.js";
+import { getPropertyName } from "./GetPropertyName.js";
+import { onWrongType } from "./OnWrongType.js";
+/**
+ * Deserializes JSON data into an existing object instance, populating its properties.
+ * This function reads metadata from @JsonProperty decorators to determine property types
+ * and performs appropriate type conversions. It supports both Serializable and plain object instances.
+ *
+ * @template T - The type of object being deserialized (extends Serializable or plain object)
+ * @param {T} obj - The target object instance to populate with deserialized data
+ * @param {object} json - The JSON object containing source data for deserialization
+ * @param {Partial<SerializationSettings>} [settings] - Optional settings to customize deserialization behavior
+ * @returns {T} The same object instance with properties populated from JSON
+ *
+ * @remarks
+ * The function performs the following steps:
+ * 1. Validates that json is an object (not null, array, or primitive)
+ * 2. Iterates through all properties of the target object
+ * 3. Resolves JSON property names using @JsonName decorators and naming strategies
+ * 4. Falls back to original property names for deep copy operations
+ * 5. Deserializes each property value according to its type metadata
+ * 6. Calls error handlers for invalid or missing data
+ *
+ * Property name resolution priority:
+ * - @JsonName decorator value
+ * - Naming strategy transformation (snake_case, camelCase, etc.)
+ * - Original property name (fallback for deep copy)
+ *
+ * @example
+ * ```typescript
+ * class User extends Serializable {
+ *   @JsonProperty(String)
+ *   name: string;
+ *
+ *   @JsonProperty(Number)
+ *   age: number;
+ * }
+ *
+ * const user = new User();
+ * fromJSON(user, { name: "John", age: 30 });
+ * console.log(user.name); // "John"
+ * console.log(user.age);  // 30
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using with plain objects (non-Serializable)
+ * class Product {
+ *   @JsonProperty(String)
+ *   title: string;
+ * }
+ *
+ * const product = new Product();
+ * fromJSON(product, { title: "Laptop" });
+ * ```
+ */
+// eslint-disable-next-line max-statements
+export const fromJSON = (obj, json, settings) => {
+    const unknownJson = json;
+    if (unknownJson === null ||
+        Array.isArray(unknownJson) ||
+        typeof unknownJson !== "object") {
+        if (obj instanceof Serializable) {
+            obj.onWrongType(String(unknownJson), "is not an object", unknownJson);
+        }
+        else {
+            onWrongType(obj, String(unknownJson), "is not an object", unknownJson);
+        }
+        return obj;
+    }
+    // eslint-disable-next-line guard-for-in
+    for (const thisProp in obj) {
+        // Naming strategy and jsonName decorator
+        let jsonProp = obj instanceof Serializable ?
+            obj.getJsonPropertyName(thisProp, settings) :
+            getPropertyName(obj, thisProp, settings);
+        // For deep copy
+        if (!unknownJson?.hasOwnProperty(jsonProp) && unknownJson?.hasOwnProperty(thisProp)) {
+            jsonProp = thisProp;
+        }
+        if (unknownJson?.hasOwnProperty(jsonProp) &&
+            obj.hasOwnProperty(thisProp) &&
+            Reflect.hasMetadata("ts-serializable:jsonTypes", obj.constructor.prototype, thisProp)) {
+            const acceptedTypes = Reflect.getMetadata("ts-serializable:jsonTypes", obj.constructor.prototype, thisProp);
+            const jsonValue = Reflect.get(unknownJson, jsonProp);
+            const extractedValue = obj instanceof Serializable ?
+                obj.deserializeProperty(thisProp, acceptedTypes, jsonValue, settings) :
+                deserializeProperty(obj, thisProp, acceptedTypes, jsonValue, settings);
+            Reflect.set(obj, thisProp, extractedValue);
+        }
+    }
+    return obj;
+};

package/dist/functions/GetPropertyName.d.ts

@@ -0,0 +1,38 @@
+import { SerializationSettings } from "../models/SerializationSettings.js";
+/**
+ * Determines the final JSON property name based on decorators, settings, and naming strategies.
+ * This function applies transformations in the following priority order:
+ * 1. @JsonName decorator (highest priority)
+ * 2. Naming strategy from method-level settings parameter
+ * 3. Naming strategy from @JsonObject decorator on the class
+ * 4. Naming strategy from Serializable.defaultSettings
+ * 5. Original property name (no transformation)
+ *
+ * @param {object} obj - The object instance containing the property
+ * @param {string} property - The original property name as defined in the class
+ * @param {Partial<SerializationSettings>} [settings] - Optional settings that may include a naming strategy
+ * @returns {string} The transformed property name to use in JSON output
+ *
+ * @example
+ * ```typescript
+ * // With @JsonName decorator
+ * class User {
+ *   @JsonName("user_id")
+ *   userId: string;
+ * }
+ * getPropertyName(user, "userId"); // Returns "user_id"
+ *
+ * // With snake_case naming strategy
+ * class Product {
+ *   @JsonProperty()
+ *   productName: string;
+ * }
+ * getPropertyName(product, "productName", { namingStrategy: new SnakeCaseNamingStrategy() });
+ * // Returns "product_name"
+ * ```
+ *
+ * @remarks
+ * The @JsonName decorator always takes precedence over any naming strategy.
+ * Naming strategies can transform property names to conventions like snake_case, kebab-case, PascalCase, etc.
+ */
+export declare const getPropertyName: (obj: object, property: string, settings?: Partial<SerializationSettings>) => string;

package/dist/functions/GetPropertyName.js

@@ -0,0 +1,56 @@
+/* eslint-disable max-statements */
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+import { Serializable } from "../classes/Serializable.js";
+/**
+ * Determines the final JSON property name based on decorators, settings, and naming strategies.
+ * This function applies transformations in the following priority order:
+ * 1. @JsonName decorator (highest priority)
+ * 2. Naming strategy from method-level settings parameter
+ * 3. Naming strategy from @JsonObject decorator on the class
+ * 4. Naming strategy from Serializable.defaultSettings
+ * 5. Original property name (no transformation)
+ *
+ * @param {object} obj - The object instance containing the property
+ * @param {string} property - The original property name as defined in the class
+ * @param {Partial<SerializationSettings>} [settings] - Optional settings that may include a naming strategy
+ * @returns {string} The transformed property name to use in JSON output
+ *
+ * @example
+ * ```typescript
+ * // With @JsonName decorator
+ * class User {
+ *   @JsonName("user_id")
+ *   userId: string;
+ * }
+ * getPropertyName(user, "userId"); // Returns "user_id"
+ *
+ * // With snake_case naming strategy
+ * class Product {
+ *   @JsonProperty()
+ *   productName: string;
+ * }
+ * getPropertyName(product, "productName", { namingStrategy: new SnakeCaseNamingStrategy() });
+ * // Returns "product_name"
+ * ```
+ *
+ * @remarks
+ * The @JsonName decorator always takes precedence over any naming strategy.
+ * Naming strategies can transform property names to conventions like snake_case, kebab-case, PascalCase, etc.
+ */
+export const getPropertyName = (obj, property, settings) => {
+    if (Reflect.hasMetadata("ts-serializable:jsonName", obj.constructor.prototype, property)) {
+        return Reflect.getMetadata("ts-serializable:jsonName", obj.constructor.prototype, property);
+    }
+    if (settings?.namingStrategy) {
+        return settings.namingStrategy.toJsonName(property);
+    }
+    if (Reflect.hasMetadata("ts-serializable:jsonObject", obj.constructor)) {
+        const objectSettings = Reflect.getMetadata("ts-serializable:jsonObject", obj.constructor);
+        return objectSettings.namingStrategy?.toJsonName(property) ?? property;
+    }
+    if (Serializable.defaultSettings.namingStrategy) {
+        const { namingStrategy } = Serializable.defaultSettings;
+        return namingStrategy.toJsonName(property);
+    }
+    return property;
+};

package/dist/functions/OnWrongType.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Default error handler for type mismatch errors during deserialization.
+ * This function is called when a JSON value cannot be converted to any of the expected types
+ * for a property. By default, it logs an error to the console.
+ *
+ * @param {object} self - The object instance being deserialized
+ * @param {string} prop - The name of the property that has a type mismatch
+ * @param {string} message - A descriptive error message explaining the type issue
+ * @param {unknown} jsonValue - The actual JSON value that caused the type mismatch
+ *
+ * @remarks
+ * This function is used for objects that don't extend the Serializable class.
+ * For Serializable instances, the instance method `onWrongType` is called instead,
+ * which can be overridden for custom error handling.
+ *
+ * @example
+ * ```typescript
+ * // Called internally when type mismatch occurs:
+ * onWrongType(userObj, "age", "is invalid", "not-a-number");
+ * // Console output: "User.fromJSON: json.age is invalid: not-a-number"
+ * ```
+ */
+export declare const onWrongType: (self: object, prop: string, message: string, jsonValue: unknown) => void;

package/dist/functions/OnWrongType.js

@@ -0,0 +1,27 @@
+/**
+ * Default error handler for type mismatch errors during deserialization.
+ * This function is called when a JSON value cannot be converted to any of the expected types
+ * for a property. By default, it logs an error to the console.
+ *
+ * @param {object} self - The object instance being deserialized
+ * @param {string} prop - The name of the property that has a type mismatch
+ * @param {string} message - A descriptive error message explaining the type issue
+ * @param {unknown} jsonValue - The actual JSON value that caused the type mismatch
+ *
+ * @remarks
+ * This function is used for objects that don't extend the Serializable class.
+ * For Serializable instances, the instance method `onWrongType` is called instead,
+ * which can be overridden for custom error handling.
+ *
+ * @example
+ * ```typescript
+ * // Called internally when type mismatch occurs:
+ * onWrongType(userObj, "age", "is invalid", "not-a-number");
+ * // Console output: "User.fromJSON: json.age is invalid: not-a-number"
+ * ```
+ */
+// eslint-disable-next-line max-params
+export const onWrongType = (self, prop, message, jsonValue) => {
+    // eslint-disable-next-line no-console
+    console.error(`${self.constructor.name}.fromJSON: json.${prop} ${message}:`, jsonValue);
+};

package/dist/functions/ToJSON.d.ts

@@ -0,0 +1,36 @@
+import { Serializable } from "../classes/Serializable.js";
+/**
+ * Serializes an object or Serializable instance to a plain JavaScript object suitable for JSON conversion.
+ * This function iterates through all own properties and creates a new object with transformed property names,
+ * respecting @JsonIgnore decorators and naming strategies.
+ *
+ * @param {Serializable | object} obj - The object or Serializable instance to serialize
+ * @returns {Record<string, unknown>} A plain object with all serializable properties
+ *
+ * @remarks
+ * - Symbol properties are automatically skipped
+ * - Properties marked with @JsonIgnore decorator are excluded
+ * - Property names are transformed according to @JsonName decorators and naming strategies
+ * - For Serializable instances, uses the instance's getJsonPropertyName method
+ * - For plain objects, uses the standalone getPropertyName function
+ *
+ * @example
+ * ```typescript
+ * class User extends Serializable {
+ *   @JsonProperty()
+ *   firstName: string = "John";
+ *
+ *   @JsonProperty()
+ *   lastName: string = "Doe";
+ *
+ *   @JsonIgnore()
+ *   password: string = "secret";
+ * }
+ *
+ * const user = new User();
+ * const json = toJSON(user);
+ * // Returns: { firstName: "John", lastName: "Doe" }
+ * // Note: password is excluded due to @JsonIgnore
+ * ```
+ */
+export declare const toJSON: (obj: Serializable | object) => Record<string, unknown>;

package/dist/functions/ToJSON.js

@@ -0,0 +1,57 @@
+/* eslint-disable @typescript-eslint/no-unsafe-argument */
+/* eslint-disable no-prototype-builtins */
+import { Serializable } from "../classes/Serializable.js";
+import { getPropertyName } from "./GetPropertyName.js";
+/**
+ * Serializes an object or Serializable instance to a plain JavaScript object suitable for JSON conversion.
+ * This function iterates through all own properties and creates a new object with transformed property names,
+ * respecting @JsonIgnore decorators and naming strategies.
+ *
+ * @param {Serializable | object} obj - The object or Serializable instance to serialize
+ * @returns {Record<string, unknown>} A plain object with all serializable properties
+ *
+ * @remarks
+ * - Symbol properties are automatically skipped
+ * - Properties marked with @JsonIgnore decorator are excluded
+ * - Property names are transformed according to @JsonName decorators and naming strategies
+ * - For Serializable instances, uses the instance's getJsonPropertyName method
+ * - For plain objects, uses the standalone getPropertyName function
+ *
+ * @example
+ * ```typescript
+ * class User extends Serializable {
+ *   @JsonProperty()
+ *   firstName: string = "John";
+ *
+ *   @JsonProperty()
+ *   lastName: string = "Doe";
+ *
+ *   @JsonIgnore()
+ *   password: string = "secret";
+ * }
+ *
+ * const user = new User();
+ * const json = toJSON(user);
+ * // Returns: { firstName: "John", lastName: "Doe" }
+ * // Note: password is excluded due to @JsonIgnore
+ * ```
+ */
+export const toJSON = (obj) => {
+    const toJson = {};
+    const keys = Reflect.ownKeys(obj);
+    for (const key of keys) {
+        if (typeof key === "symbol") {
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        if (obj.hasOwnProperty(key)) {
+            if (Reflect.getMetadata("ts-serializable:jsonIgnore", obj.constructor.prototype, key) !== true) {
+                const toProp = obj instanceof Serializable ?
+                    obj.getJsonPropertyName(key) :
+                    getPropertyName(obj, key);
+                Reflect.set(toJson, toProp, Reflect.get(obj, key));
+            }
+        }
+    }
+    return toJson;
+};

package/dist/index.d.ts

@@ -15,5 +15,9 @@ export { SnakeCaseNamingStrategy } from "./naming-strategies/SnakeCaseNamingStra
 export { PascalCaseNamingStrategy } from "./naming-strategies/PascalCaseNamingStrategy.js";
 export { KebabCaseNamingStrategy } from "./naming-strategies/KebabCaseNamingStrategy.js";
 export { CamelCaseNamingStrategy } from "./naming-strategies/CamelCaseNamingStrategy.js";
-export { classToFormData } from "./utils/ClassToFormData.js";
-export { getPropertyName } from "./utils/GetProperyName.js";
+export { classToFormData } from "./functions/ClassToFormData.js";
+export { deserializeProperty } from "./functions/DeserializeProperty.js";
+export { fromJSON } from "./functions/FromJSON.js";
+export { getPropertyName } from "./functions/GetPropertyName.js";
+export { onWrongType } from "./functions/OnWrongType.js";
+export { toJSON } from "./functions/ToJSON.js";

package/dist/index.js

@@ -18,6 +18,10 @@ export { SnakeCaseNamingStrategy } from "./naming-strategies/SnakeCaseNamingStra
 export { PascalCaseNamingStrategy } from "./naming-strategies/PascalCaseNamingStrategy.js";
 export { KebabCaseNamingStrategy } from "./naming-strategies/KebabCaseNamingStrategy.js";
 export { CamelCaseNamingStrategy } from "./naming-strategies/CamelCaseNamingStrategy.js";
-// Utils
-export { classToFormData } from "./utils/ClassToFormData.js";
-export { getPropertyName } from "./utils/GetProperyName.js";
+// Functions
+export { classToFormData } from "./functions/ClassToFormData.js";
+export { deserializeProperty } from "./functions/DeserializeProperty.js";
+export { fromJSON } from "./functions/FromJSON.js";
+export { getPropertyName } from "./functions/GetPropertyName.js";
+export { onWrongType } from "./functions/OnWrongType.js";
+export { toJSON } from "./functions/ToJSON.js";

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "ts-serializable",
-    "version": "4.2.2",
+    "version": "4.3.2",
     "author": "Eugene Labutin",
     "license": "MIT",
     "homepage": "https://github.com/LabEG/Serializable#readme",
@@ -34,17 +34,17 @@
         "reflect-metadata": ">=0.1.0"
     },
     "devDependencies": {
-        "@commitlint/cli": "^19.8.1",
-        "@commitlint/config-conventional": "^19.8.1",
+        "@commitlint/cli": "^20.1.0",
+        "@commitlint/config-conventional": "^20.0.0",
         "@favware/cliff-jumper": "^6.0.0",
         "@labeg/code-style": "^6.5.0",
-        "@swc-node/register": "^1.10.10",
+        "@swc-node/register": "^1.11.1",
         "@types/chai": "^5.2.2",
-        "chai": "^5.2.1",
+        "chai": "^6.2.0",
         "husky": "^9.1.7",
-        "lint-staged": "^16.1.2",
+        "lint-staged": "^16.2.3",
         "reflect-metadata": "^0.2.2",
-        "typescript": "^5.8.3"
+        "typescript": "^5.9.3"
     },
     "keywords": [
         "serialization",

package/dist/utils/ClassToFormData.d.ts

@@ -1,9 +0,0 @@
-/**
- * Converts a class instance to FormData for use in AJAX forms.
- *
- * @param {object} obj - The class instance to convert.
- * @param {string} [formPrefix] - Optional prefix for form property names.
- * @param {FormData} [formData] - Optional existing FormData to update.
- * @returns {FormData} - The resulting FormData object.
- */
-export declare const classToFormData: (obj: object, formPrefix?: string, formData?: FormData) => FormData;

package/dist/utils/GetProperyName.d.ts

@@ -1,10 +0,0 @@
-import { SerializationSettings } from "../models/SerializationSettings.js";
-/**
- * Retrieves the correct property name for serialization, considering decorators and settings.
- *
- * @param {object} obj - The object containing the property.
- * @param {string} property - The source name of the property.
- * @param {Partial<SerializationSettings>} [settings] - Optional serialization settings.
- * @returns {string} - The correct property name for serialization.
- */
-export declare const getPropertyName: (obj: object, property: string, settings?: Partial<SerializationSettings>) => string;

package/dist/utils/GetProperyName.js

@@ -1,28 +0,0 @@
-/* eslint-disable max-statements */
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
-import { Serializable } from "../classes/Serializable.js";
-/**
- * Retrieves the correct property name for serialization, considering decorators and settings.
- *
- * @param {object} obj - The object containing the property.
- * @param {string} property - The source name of the property.
- * @param {Partial<SerializationSettings>} [settings] - Optional serialization settings.
- * @returns {string} - The correct property name for serialization.
- */
-export const getPropertyName = (obj, property, settings) => {
-    if (Reflect.hasMetadata("ts-serializable:jsonName", obj.constructor.prototype, property)) {
-        return Reflect.getMetadata("ts-serializable:jsonName", obj.constructor.prototype, property);
-    }
-    if (settings?.namingStrategy) {
-        return settings.namingStrategy.toJsonName(property);
-    }
-    if (Reflect.hasMetadata("ts-serializable:jsonObject", obj.constructor)) {
-        const objectSettings = Reflect.getMetadata("ts-serializable:jsonObject", obj.constructor);
-        return objectSettings.namingStrategy?.toJsonName(property) ?? property;
-    }
-    if (Serializable.defaultSettings.namingStrategy) {
-        const { namingStrategy } = Serializable.defaultSettings;
-        return namingStrategy.toJsonName(property);
-    }
-    return property;
-};