tinspector - npm Package Compare versions

Comparing version 3.2.0 to 3.2.1

lib/decorators.js

@@ -114,4 +114,3 @@ "use strict";
         const opt = (typeof parent === "object") ? parent : { parent: parent, name: "DynamicType" };
-        const Type = helpers_1.metadata.createClass(opt.parent, opt.name);
-        Reflect.decorate([generic.type(...params)], Type);
+        const Type = helpers_1.createClass(Object.assign(Object.assign({}, opt), { genericParams: params }));
         return Type;
@@ -118,0 +117,0 @@ }

lib/helpers.d.ts

@@ -1,7 +0,6 @@
-import { Class, ParameterPropertyReflection, ClassReflection } from "./types";
+import { Class, ParameterPropertyReflection, ClassReflection, TypeOverride } from "./types";
 declare function useCache<K, P extends any[], R>(cache: Map<K, R>, fn: (...args: P) => R, getKey: (...args: P) => K): (...args: P) => R;
 declare namespace metadata {
-    function createClass(parent: Class, name: string): Class;
     function isParameterProperties(meta: any): meta is ParameterPropertyReflection;
-    function isCallback(type: any): type is ((x: any) => Class[] | Class | string | string[]);
+    function isCallback(type: any): type is ((x: any) => TypeOverride);
     function isConstructor(value: any): boolean;
@@ -22,2 +21,12 @@ function isCustomClass(type: Function | Function[]): boolean;
 }
-export { useCache, metadata };
+declare type CustomTypeDefinition = {
+    [key: string]: Class | Class[];
+};
+interface CreateClassOption {
+    parent: Class;
+    definition: CustomTypeDefinition;
+    name: string;
+    genericParams: TypeOverride[];
+}
+declare function createClass(opt?: Partial<CreateClassOption>): Class;
+export { useCache, metadata, createClass, CustomTypeDefinition, CreateClassOption };

lib/helpers.js

@@ -5,4 +5,24 @@ "use strict";
 /* ---------------------------------------------------------------- */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.metadata = exports.useCache = void 0;
+exports.createClass = exports.metadata = exports.useCache = void 0;
+const decorate = __importStar(require("./decorators"));
 function useCache(cache, fn, getKey) {
@@ -24,7 +44,2 @@ return (...args) => {
 (function (metadata) {
-    function createClass(parent, name) {
-        return { [name]: class extends parent {
-            } }[name];
-    }
-    metadata.createClass = createClass;
     function isParameterProperties(meta) {
@@ -74,1 +89,12 @@ return meta && meta.kind === "Property" && meta.isParameter;
 exports.metadata = metadata;
+function createClass(opt) {
+    const option = Object.assign({ parent: Object, name: "DynamicType", definition: {}, genericParams: [] }, opt);
+    const type = { [option.name]: class extends option.parent {
+        } }[option.name];
+    for (const key in option.definition) {
+        Reflect.decorate([decorate.type(option.definition[key])], type.prototype, key);
+    }
+    Reflect.decorate([decorate.generic.type(...option.genericParams)], type);
+    return type;
+}
+exports.createClass = createClass;

lib/parser.js

@@ -59,3 +59,3 @@ "use strict";
     const code = fn.toString();
-    if (code.search(/^class(\s*)extends\s*parent\s*{\s*}/gm) > -1) {
+    if (code.search(/^class(\s*)extends\s*option.parent\s*{\s*}/gm) > -1) {
         return "class DynamicClass extends parent {}";
@@ -62,0 +62,0 @@ }

lib/reflect.d.ts

@@ -0,1 +1,3 @@
+import * as decorate from "./decorators";
+import { createClass } from "./helpers";
 import { Class, ClassReflection, ObjectReflection } from "./types";
@@ -14,6 +16,7 @@ interface ReflectOption {
 declare namespace reflect {
-    var noop: typeof import("./decorators").noop;
-    var ignore: typeof import("./decorators").ignore;
-    var type: typeof import("./decorators").type;
-    var parameterProperties: typeof import("./decorators").parameterProperties;
+    var noop: typeof decorate.noop;
+    var ignore: typeof decorate.ignore;
+    var type: typeof decorate.type;
+    var create: typeof createClass;
+    var parameterProperties: typeof decorate.parameterProperties;
 }
@@ -26,7 +29,8 @@ /**
 declare namespace reflect {
-    var noop: typeof import("./decorators").noop;
-    var ignore: typeof import("./decorators").ignore;
-    var type: typeof import("./decorators").type;
-    var parameterProperties: typeof import("./decorators").parameterProperties;
+    var noop: typeof decorate.noop;
+    var ignore: typeof decorate.ignore;
+    var type: typeof decorate.type;
+    var create: typeof createClass;
+    var parameterProperties: typeof decorate.parameterProperties;
 }
 export { reflect };

lib/reflect.js

@@ -78,4 +78,8 @@ "use strict";
 /**
+ * Create class dynamically
+ */
+reflect.create = helpers_1.createClass;
+/**
  * Mark all constructor parameters as properties
  */
 reflect.parameterProperties = decorators_1.parameterProperties;

lib/types.d.ts

@@ -0,5 +1,6 @@
+import { CustomTypeDefinition } from "./helpers";
 export declare const DecoratorOptionId: unique symbol;
 export declare const DecoratorId: unique symbol;
 export declare type Class<T = any> = new (...arg: any[]) => T;
-export declare type TypeOverride = string | string[] | Class | Class[];
+export declare type TypeOverride = string | string[] | Class | Class[] | CustomTypeDefinition | CustomTypeDefinition[];
 export declare type DecoratorIterator = (type: DecoratorTargetType, target: string, index?: number) => any[];
@@ -6,0 +7,0 @@ export declare type DecoratorTargetType = "Method" | "Class" | "Parameter" | "Property";

lib/walker.js

@@ -19,3 +19,2 @@ "use strict";
 const types_1 = require("./types");
-const decorators_1 = require("./decorators");
 // --------------------------------------------------------------------- //
@@ -37,2 +36,3 @@ // -------------------------- VISITOR HELPERS -------------------------- //
 function getTypeOverrideFromDecorator(decorators) {
+    const getType = (type) => typeof type === "object" ? helpers_1.createClass({ definition: type }) : type;
     const override = decorators.find((x) => x.kind === "Override");
@@ -42,4 +42,4 @@ if (!override)
     // extract type from the callback
-    const type = helpers_1.metadata.isCallback(override.type) ? override.type({}) : override.type;
-    return { type, genericParams: override.genericParams };
+    const rawType = helpers_1.metadata.isCallback(override.type) ? override.type({}) : override.type;
+    return { type: Array.isArray(rawType) ? [getType(rawType[0])] : getType(rawType), genericParams: override.genericParams };
 }
@@ -158,3 +158,3 @@ class GenericMap {
             }
-            return decorators_1.generic.create(decorator.type, ...converted);
+            return helpers_1.createClass({ parent: decorator.type, genericParams: converted });
         };
@@ -161,0 +161,0 @@ if (meta.kind === "Constructor" || meta.kind === "Class")

package.json

 {
   "name": "tinspector",
-  "version": "3.2.0",
+  "version": "3.2.1",
   "description": "TypeScript type inspector",
@@ -5,0 +5,0 @@ "main": "lib/index.js",

No alert changes

Improved metrics

Total package byte prevSize

62684

increased by3.12%

Lines of code

1118

increased by4%

No dependency changes