@tsed/json-mapper 7.34.5 → 7.35.0-beta.2

package/lib/types/domain/JsonMapperCompiler.d.ts

@@ -0,0 +1,52 @@
+import { Type } from "@tsed/core";
+import { JsonSchema } from "@tsed/schema";
+export type JsonMapperCallback<Options> = (input: any, options?: Options) => any;
+export type CachedJsonMapper<Options> = {
+    id: string;
+    fn: JsonMapperCallback<Options>;
+};
+export type CachedGroupsJsonMapper<Options> = Map<string, CachedJsonMapper<Options>>;
+export declare abstract class JsonMapperCompiler<Options extends Record<string, any> = any> {
+    /**
+     * Cached mappers metadata
+     * @protected
+     */
+    protected cache: Map<string | Type<any>, CachedGroupsJsonMapper<Options>>;
+    /**
+     * Cached executable mappers by his id
+     * @protected
+     */
+    protected mappers: Record<string, JsonMapperCallback<Options>>;
+    /**
+     * Cached schemas
+     * @protected
+     */
+    protected schemes: Record<string, any>;
+    /**
+     * Global variables available in the mapper
+     * @protected
+     */
+    protected globals: Record<string, any>;
+    constructor();
+    addTypeMapper(model: Type<any> | string, fn: any): this;
+    removeTypeMapper(model: Type<any> | string): void;
+    addGlobal(key: string, value: any): this;
+    eval(mapper: string, { id, groupsId, model }: {
+        id: string;
+        model: Type<any>;
+        groupsId: string;
+    }): CachedJsonMapper<Options>;
+    createContext(options: Options): Options & {
+        cache: Map<string | Type<any>, CachedGroupsJsonMapper<Options>>;
+    };
+    compile(model: Type<any>, groups: false | string[]): CachedJsonMapper<Options>;
+    protected execMapper(id: string, value: any, options: Options): any;
+    protected abstract map(input: any, options: Options): any;
+    protected abstract alterValue(schemaId: string, value: any, options: Options): any;
+    protected abstract createMapper(model: Type<any>, id: string, groups: false | string[]): string;
+    protected getType(model: Type<any>): Type<any> | ArrayConstructor | MapConstructor | SetConstructor | ObjectConstructor;
+    protected alterIgnore(id: string, options: Options): any;
+    protected alterGroups(schema: JsonSchema, groups: false | string[]): any;
+    protected getGroupsId(groups: false | string[]): string;
+    protected getId(model: Type<any>, groupsId: string): string;
+}

package/lib/types/domain/JsonSerializer.d.ts

@@ -0,0 +1,20 @@
+import { Type } from "@tsed/core";
+import { JsonMapperCompiler } from "./JsonMapperCompiler";
+import { JsonSerializerOptions } from "./JsonSerializerOptions";
+export declare class JsonSerializer extends JsonMapperCompiler<JsonSerializerOptions> {
+    constructor();
+    map(input: any, options?: JsonSerializerOptions): any;
+    protected alterValue(schemaId: string, value: any, options: JsonSerializerOptions): any;
+    protected createMapper(model: Type<any>, id: string, groups: false | string[]): string;
+    private mapOptions;
+    private mapProperty;
+    private mapPrecondition;
+    private mapDiscriminator;
+    private mapAdditionalProperties;
+    private mapObject;
+    private mapSet;
+    private mapArray;
+    private mapMap;
+    private mapItem;
+    private mapJSON;
+}

package/lib/types/domain/JsonSerializerOptions.d.ts

@@ -0,0 +1,13 @@
+import { MetadataTypes, Type } from "@tsed/core";
+import { JsonMapperMethods } from "../interfaces/JsonMapperMethods";
+export interface JsonSerializerOptions<T = any, C = any> extends MetadataTypes<T, C> {
+    /**
+     * Types used to map complex types (Symbol, Number, String, etc...)
+     */
+    types?: Map<Type<any> | Symbol | string, JsonMapperMethods>;
+    /**
+     * useAlias mapping
+     */
+    useAlias?: boolean;
+    [key: string]: any;
+}

package/lib/types/domain/Writer.d.ts

@@ -0,0 +1,34 @@
+export declare class Writer {
+    static object: {
+        assign(...args: string[]): string;
+    };
+    protected _root?: Writer;
+    protected body: (string | Writer)[];
+    private _indent;
+    constructor(root?: Writer);
+    static indent(lines: string[]): string[];
+    static mapper(mapperId: string, key: string, options: string): string;
+    static mapperFrom(key: string, options: string): string;
+    static options(...args: string[]): string;
+    add(...lines: (undefined | string | Writer)[]): this;
+    arrow(...args: string[]): Writer;
+    build(): string[];
+    callMapper(id: string, key: string, ...options: string[]): this;
+    const(name: string, line: string): this;
+    each(iterable: string, args?: string[]): Writer;
+    if(condition: string): IfWriter;
+    indent(indent: boolean): this;
+    new(indent?: boolean): Writer;
+    return(line: string): Writer;
+    root(): Writer;
+    set(left: string, right: string): this;
+    toString(): string;
+}
+declare class IfWriter extends Writer {
+    protected condition: string;
+    protected elseWriter?: Writer;
+    constructor(condition: string, root: Writer);
+    else(): Writer;
+    build(): string[];
+}
+export {};

package/lib/types/hooks/alterOnSerialize.d.ts

@@ -0,0 +1,2 @@
+import { JsonHookContext, JsonSchema } from "@tsed/schema";
+export declare function alterOnSerialize(schema: JsonSchema, value: any, options: JsonHookContext): any;

package/lib/types/index.d.ts

@@ -12,11 +12,17 @@ export * from "./decorators/beforeDeserialize";
 export * from "./decorators/jsonMapper";
 export * from "./decorators/onDeserialize";
 export * from "./decorators/onSerialize";
+export * from "./domain/JsonMapperCompiler";
 export * from "./domain/JsonMapperContext";
 export * from "./domain/JsonMapperSettings";
 export * from "./domain/JsonMapperTypesContainer";
+export * from "./domain/JsonSerializer";
+export * from "./domain/JsonSerializerOptions";
+export * from "./domain/Writer";
 export * from "./hooks/alterAfterDeserialize";
 export * from "./hooks/alterBeforeDeserialize";
+export * from "./hooks/alterOnSerialize";
 export * from "./interfaces/JsonMapperMethods";
 export * from "./utils/deserialize";
+export * from "./utils/getObjectProperties";
 export * from "./utils/serialize";

package/lib/types/utils/getObjectProperties.d.ts

@@ -0,0 +1 @@
+export declare function getObjectProperties(obj: any): [string, any][];

package/lib/types/utils/serialize.d.ts

@@ -1,21 +1,5 @@
-import { MetadataTypes, Type } from "@tsed/core";
-import "../components/ArrayMapper";
 import "../components/DateMapper";
-import "../components/MapMapper";
 import "../components/PrimitiveMapper";
-import "../components/SetMapper";
 import "../components/SymbolMapper";
-import { JsonMapperMethods } from "../interfaces/JsonMapperMethods";
-export interface JsonSerializerOptions<T = any, C = any> extends MetadataTypes<T, C> {
-    /**
-     * Types used to map complex types (Symbol, Array, Set, Map)
-     */
-    types?: Map<Type<any>, JsonMapperMethods>;
-    /**
-     * useAlias mapping
-     */
-    useAlias?: boolean;
-    [key: string]: any;
-}
-export declare function classToPlainObject(obj: any, options: JsonSerializerOptions<any, any>): any;
-export declare function serialize(obj: any, { type, collectionType, groups, ...options }?: JsonSerializerOptions): any;
+import { JsonSerializerOptions } from "../domain/JsonSerializerOptions";
+export declare function serialize(input: any, options?: JsonSerializerOptions): any;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsed/json-mapper",
-  "version": "7.34.5",
+  "version": "7.35.0-beta.2",
   "description": "Json mapper module for Ts.ED Framework",
   "private": false,
   "source": "./src/index.ts",
@@ -41,15 +41,15 @@
     "tslib": "2.5.0"
   },
   "devDependencies": {
-    "@tsed/core": "7.34.5",
-    "@tsed/eslint": "7.34.5",
-    "@tsed/schema": "7.34.5",
-    "@tsed/typescript": "7.34.5",
+    "@tsed/core": "7.35.0-beta.2",
+    "@tsed/eslint": "7.35.0-beta.2",
+    "@tsed/schema": "7.35.0-beta.2",
+    "@tsed/typescript": "7.35.0-beta.2",
     "eslint": "^8.12.0"
   },
   "peerDependencies": {
-    "@tsed/core": "^7.34.5",
-    "@tsed/schema": "^7.34.5"
+    "@tsed/core": "^7.35.0-beta.2",
+    "@tsed/schema": "^7.35.0-beta.2"
   },
   "peerDependenciesMeta": {
     "@tsed/core": {
@@ -65,5 +65,8 @@
   },
   "homepage": "https://github.com/tsedio/tsed/tree/production/packages/specs/json-mapper",
   "author": "Romain Lenzotti",
-  "license": "MIT"
+  "license": "MIT",
+  "publishConfig": {
+    "tag": "beta"
+  }
 }