@prostojs/mate 0.3.2 → 0.4.0

package/package.json

@@ -1,81 +1,70 @@
 {
-  "name": "@prostojs/mate",
-  "version": "0.3.2",
-  "description": "MATE is TS Metadata Organizer",
-  "main": "index.js",
-  "module": "dist/mate.esm-bundler.js",
-  "types": "dist/mate.d.ts",
-  "files": [
-    "index.js",
-    "dist"
-  ],
-  "scripts": {
-    "build": "node ./scripts/build",
-    "release": "node ./scripts/release",
-    "test": "jest --runInBand",
-    "test:cov": "jest --runInBand --coverage",
-    "lint": "eslint --ext .ts src/**.ts --fix",
-    "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s",
-    "version": "conventional-changelog -p angular -i CHANGELOG.md -s && git add CHANGELOG.md"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/prostojs/mate.git"
-  },
-  "keywords": [
-    "metadata",
-    "decorators",
-    "mate",
-    "prostojs"
-  ],
-  "buildOptions": {
-    "name": "ProstoMate",
-    "formats": [
-      "esm-bundler",
-      "cjs"
-    ]
-  },
-  "dependencies": {},
-  "gitHooks": {
-    "commit-msg": "node scripts/verifyCommit.js"
-  },
-  "author": "Artem Maltsev",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/prostojs/mate/issues"
-  },
-  "homepage": "https://github.com/prostojs/mate#readme",
-  "devDependencies": {
-    "@microsoft/api-extractor": "^7.30.0",
-    "@prostojs/dye": "^0.3.0",
-    "@rollup/plugin-commonjs": "^21.0.0",
-    "@rollup/plugin-node-resolve": "^13.0.6",
-    "@rollup/plugin-replace": "^3.0.0",
-    "@types/jest": "^27.5.2",
-    "@types/node": "^16.11.57",
-    "@typescript-eslint/eslint-plugin": "^4.33.0",
-    "@typescript-eslint/parser": "^4.33.0",
-    "brotli": "^1.3.3",
-    "conventional-changelog": "^3.1.24",
-    "conventional-changelog-cli": "^2.1.1",
-    "enquirer": "^2.3.6",
-    "eslint": "^7.32.0",
-    "eslint-config-prettier": "^8.3.0",
-    "eslint-plugin-import": "^2.24.2",
-    "execa": "^5.1.1",
-    "fs-extra": "^10.0.0",
-    "jest": "^27.2.5",
-    "minimist": "^1.2.6",
-    "reflect-metadata": "^0.1.13",
-    "rollup": "^2.58.0",
-    "rollup-plugin-terser": "^7.0.2",
-    "rollup-plugin-typescript2": "^0.30.0",
-    "semver": "^7.3.5",
-    "ts-jest": "^27.0.5",
-    "ts-node": "^10.9.1",
-    "tslib": "^2.3.1",
-    "typescript": "^4.8.2",
-    "yorkie": "^2.0.0",
-    "zlib": "^1.0.5"
-  }
+    "name": "@prostojs/mate",
+    "version": "0.4.0",
+    "description": "MATE is TS Metadata Organizer",
+    "keywords": [
+        "decorators",
+        "mate",
+        "metadata",
+        "prostojs"
+    ],
+    "homepage": "https://github.com/prostojs/mate#readme",
+    "bugs": {
+        "url": "https://github.com/prostojs/mate/issues"
+    },
+    "license": "MIT",
+    "author": "Artem Maltsev",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/prostojs/mate.git"
+    },
+    "files": [
+        "dist"
+    ],
+    "main": "dist/index.cjs",
+    "module": "dist/index.mjs",
+    "types": "dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.mjs",
+            "require": "./dist/index.cjs"
+        },
+        "./package.json": "./package.json"
+    },
+    "scripts": {
+        "build": "tsc -p tsconfig.build.json && rolldown -c rolldown.config.mjs && rm -rf dts-build",
+        "release": "node ./scripts/release",
+        "test": "vitest run",
+        "test:cov": "vitest run --coverage",
+        "lint": "oxlint",
+        "lint:fix": "oxlint --fix",
+        "format": "oxfmt",
+        "format:check": "oxfmt --check",
+        "changelog": "conventional-changelog -p angular -i CHANGELOG.md -s",
+        "version": "conventional-changelog -p angular -i CHANGELOG.md -s && git add CHANGELOG.md"
+    },
+    "devDependencies": {
+        "@prostojs/dye": "^0.4.9",
+        "@swc/core": "^1.15.13",
+        "@types/node": "^22.19.11",
+        "conventional-changelog": "^3.1.25",
+        "conventional-changelog-cli": "^2.2.2",
+        "enquirer": "^2.4.1",
+        "execa": "^5.1.1",
+        "minimist": "^1.2.8",
+        "oxfmt": "^0.35.0",
+        "oxlint": "^1.50.0",
+        "reflect-metadata": "^0.1.14",
+        "rolldown": "1.0.0-rc.5",
+        "rolldown-plugin-dts": "^0.22.1",
+        "semver": "^7.7.4",
+        "typescript": "^5.9.3",
+        "unplugin-swc": "^1.5.9",
+        "vitest": "^3.2.4",
+        "yorkie": "^2.0.0"
+    },
+    "gitHooks": {
+        "commit-msg": "node scripts/verifyCommit.js"
+    }
 }

package/dist/mate.cjs.prod.js

@@ -1,232 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function getConstructor(instance) {
-    return isConstructor(instance) ?
-        instance : instance.constructor ?
-        instance.constructor : Object.getPrototypeOf(instance).constructor;
-}
-function isConstructor(v) {
-    return typeof v === 'function' && Object.getOwnPropertyNames(v).includes('prototype') && !Object.getOwnPropertyNames(v).includes('caller') && !!v.name;
-}
-
-const classMetadata = new WeakMap();
-const paramMetadata = new WeakMap();
-const root = typeof global === 'object' ? global : typeof self === 'object' ? self : {};
-function getMetaObject(target, prop) {
-    const isParam = typeof prop !== 'undefined';
-    const metadata = isParam ? paramMetadata : classMetadata;
-    const targetKey = getConstructor(target);
-    let meta = metadata.get(targetKey);
-    if (!meta) {
-        meta = {};
-        metadata.set(targetKey, meta);
-    }
-    if (isParam) {
-        meta = (meta[prop] =
-            meta[prop] || {});
-    }
-    return meta;
-}
-const _reflect = {
-    getOwnMetadata(key, target, prop) {
-        return getMetaObject(target, prop)[key];
-    },
-    defineMetadata(key, data, target, prop) {
-        const meta = getMetaObject(target, prop);
-        meta[key] = data;
-    },
-    metadata(key, data) {
-        return ((target, propKey) => {
-            Reflect$1.defineMetadata(key, data, target, propKey);
-        });
-    },
-};
-if (!root.Reflect) {
-    root.Reflect = _reflect;
-}
-else {
-    const funcs = [
-        'getOwnMetadata',
-        'defineMetadata',
-        'metadata',
-    ];
-    const target = root.Reflect;
-    for (const func of funcs) {
-        if (typeof target[func] !== 'function') {
-            Object.defineProperty(target, func, { configurable: true, writable: true, value: _reflect[func] });
-        }
-    }
-}
-const Reflect$1 = _reflect;
-
-const Reflect = (global === null || global === void 0 ? void 0 : global.Reflect) || (self === null || self === void 0 ? void 0 : self.Reflect) || Reflect$1;
-class Mate {
-    constructor(workspace, options = {}) {
-        this.workspace = workspace;
-        this.options = options;
-        this.logger = options.logger || console;
-    }
-    set(args, key, value, isArray) {
-        var _a;
-        let level = 'CLASS';
-        const newArgs = args.level === 'CLASS' ? { target: args.target }
-            : args.level === 'PROP' ? { target: args.target, propKey: args.propKey }
-                : args;
-        let meta = (Reflect.getOwnMetadata(this.workspace, newArgs.target, newArgs.propKey) || {});
-        if (newArgs.propKey && this.options.readReturnType && !meta.returnType && args.descriptor) {
-            meta.returnType = Reflect.getOwnMetadata('design:returntype', newArgs.target, newArgs.propKey);
-        }
-        if (newArgs.propKey && this.options.readType && !meta.type) {
-            meta.type = Reflect.getOwnMetadata('design:type', newArgs.target, newArgs.propKey);
-        }
-        const { index } = newArgs;
-        const cb = typeof key === 'function' ? key : undefined;
-        let data = meta;
-        if (!data.params) {
-            data.params = (_a = Reflect.getOwnMetadata('design:paramtypes', newArgs.target, newArgs.propKey)) === null || _a === void 0 ? void 0 : _a.map((f) => ({ type: f }));
-        }
-        if (typeof index === 'number') {
-            level = 'PARAM';
-            data.params = data.params || [];
-            data.params[index] = data.params[index] || {
-                type: undefined,
-            };
-            if (cb) {
-                data.params[index] = cb(data.params[index], level, args.propKey, typeof args.index === 'number' ? args.index : undefined);
-            }
-            else {
-                data = data.params[index];
-            }
-        }
-        else if (!index && !args.descriptor && args.propKey && this.options.collectPropKeys && args.level !== 'CLASS') {
-            this.set({ ...args, level: 'CLASS' }, (meta) => {
-                if (!meta.properties) {
-                    meta.properties = [args.propKey];
-                }
-                else if (!meta.properties.includes(args.propKey)) {
-                    meta.properties.push(args.propKey);
-                }
-                return meta;
-            });
-        }
-        level = typeof index === 'number' ? 'PARAM' : newArgs.propKey && newArgs.descriptor ? 'METHOD' : newArgs.propKey ? 'PROP' : 'CLASS';
-        if (typeof key !== 'function') {
-            if (isArray) {
-                const newArray = (data[key] || []);
-                if (!Array.isArray(newArray)) {
-                    this.logger.error('Mate.add (isArray=true) called for non-array metadata');
-                }
-                newArray.unshift(value);
-                data[key] = newArray;
-            }
-            else {
-                data[key] = value;
-            }
-        }
-        else if (cb && typeof index !== 'number') {
-            meta = cb(data, level, args.propKey, typeof args.index === 'number' ? args.index : undefined);
-        }
-        Reflect.defineMetadata(this.workspace, meta, newArgs.target, newArgs.propKey);
-    }
-    read(target, propKey) {
-        var _a;
-        const isConstr = isConstructor(target);
-        const constructor = isConstr ? target : getConstructor(target);
-        const proto = constructor.prototype;
-        let ownMeta = Reflect.getOwnMetadata(this.workspace, typeof propKey === 'string' ? proto : constructor, propKey);
-        if (ownMeta && propKey === undefined && ownMeta.params === undefined) {
-            const parent = Object.getPrototypeOf(constructor);
-            if (typeof parent === 'function' &&
-                parent !== fnProto &&
-                parent !== constructor) {
-                ownMeta.params = (_a = this.read(parent)) === null || _a === void 0 ? void 0 : _a.params;
-            }
-        }
-        if (this.options.inherit) {
-            const inheritFn = typeof this.options.inherit === 'function'
-                ? this.options.inherit
-                : undefined;
-            let shouldInherit = this.options.inherit;
-            if (inheritFn) {
-                if (typeof propKey === 'string') {
-                    const classMeta = Reflect.getOwnMetadata(this.workspace, constructor);
-                    shouldInherit = inheritFn(classMeta, ownMeta, 'PROP', propKey);
-                }
-                else {
-                    shouldInherit = inheritFn(ownMeta, ownMeta, 'CLASS');
-                }
-            }
-            if (shouldInherit) {
-                const parent = Object.getPrototypeOf(constructor);
-                if (typeof parent === 'function' &&
-                    parent !== fnProto &&
-                    parent !== constructor) {
-                    const inheritedMeta = (this.read(parent, propKey) ||
-                        {});
-                    const ownParams = ownMeta === null || ownMeta === void 0 ? void 0 : ownMeta.params;
-                    ownMeta = { ...inheritedMeta, ...ownMeta };
-                    if (typeof propKey === 'string' &&
-                        ownParams &&
-                        (inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params)) {
-                        for (let i = 0; i < ownParams.length; i++) {
-                            if (typeof (inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params[i]) !==
-                                'undefined') {
-                                const ownParam = ownParams[i];
-                                if (ownMeta.params &&
-                                    inheritFn &&
-                                    inheritFn(ownMeta, ownParam, 'PARAM', typeof propKey === 'string'
-                                        ? propKey
-                                        : undefined)) {
-                                    ownMeta.params[i] = {
-                                        ...inheritedMeta === null || inheritedMeta === void 0 ? void 0 : inheritedMeta.params[i],
-                                        ...ownParams[i],
-                                    };
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return ownMeta;
-    }
-    apply(...decorators) {
-        return ((target, propKey, descriptor) => {
-            for (const d of decorators) {
-                d(target, propKey, descriptor);
-            }
-        });
-    }
-    decorate(key, value, isArray, level) {
-        return ((target, propKey, descriptor) => {
-            const args = {
-                target,
-                propKey,
-                descriptor: typeof descriptor === 'number' ? undefined : descriptor,
-                index: typeof descriptor === 'number' ? descriptor : undefined,
-                level,
-            };
-            this.set(args, key, value, isArray);
-        });
-    }
-    decorateConditional(ccb) {
-        return ((target, propKey, descriptor) => {
-            const hasIndex = typeof descriptor === 'number';
-            const decoratorLevel = hasIndex ? 'PARAM' : propKey && descriptor ? 'METHOD' : propKey ? 'PROP' : 'CLASS';
-            const d = ccb(decoratorLevel);
-            if (d) {
-                d(target, propKey, descriptor);
-            }
-        });
-    }
-    decorateClass(key, value, isArray) {
-        return this.decorate(key, value, isArray, 'CLASS');
-    }
-}
-const fnProto = Object.getPrototypeOf(Function);
-
-exports.Mate = Mate;
-exports.getConstructor = getConstructor;
-exports.isConstructor = isConstructor;

package/dist/mate.d.ts

@@ -1,83 +0,0 @@
-declare type ArrayElementType<T> = T extends (infer E)[] ? E : never;
-
-export declare function getConstructor<T = TAny>(instance: T): TFunction;
-
-export declare function isConstructor<T = TAny>(v: T): v is (T & TClassConstructor);
-
-export declare class Mate<TClass extends TObject = TMateClassMeta<TMateParamMeta>, TProp extends {
-    params: TMateParamMeta[];
-} = Required<TMatePropMeta<TMateParamMeta>>> {
-    protected workspace: string;
-    protected options: TMateOptions<TClass, TProp>;
-    protected logger: TConsoleBase;
-    constructor(workspace: string, options?: TMateOptions<TClass, TProp>);
-    set<T = TClass & TProp & TCommonMateWithParam<TProp['params'][0]>>(args: TMergedDecoratorArgs, cb: ((meta: T, level: TLevels, propKey?: string | symbol, index?: number) => T)): void;
-    set<T = TClass & TProp & TCommonMateWithParam<TProp['params'][0]>, K extends keyof T = keyof T>(args: TMergedDecoratorArgs, key: keyof T, value: T[K]): void;
-    set<T = TClass & TProp & TCommonMateWithParam<TProp['params'][0]>, K extends keyof T = keyof T>(args: TMergedDecoratorArgs, key: keyof T, value: T[K], isArray: boolean | undefined): void;
-    read<PK>(target: TFunction | TObject, propKey?: PK): PK extends PropertyKey ? (TClass & TProp & TCommonMate<TProp['params'][0]> | undefined) : TClass | undefined;
-    apply(...decorators: (MethodDecorator | ClassDecorator | ParameterDecorator | PropertyDecorator)[]): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-    decorate<T = TClass & TProp & TCommonMateWithParam<TProp['params'][0]>>(cb: ((meta: T, level: TLevels, propKey?: string | symbol, index?: number) => T)): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-    decorate<T = TClass & TProp & TCommonMateWithParam<TProp['params'][0]>, K extends keyof T = keyof T>(key: K, value: T[K]): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-    decorate<T = TClass & TProp & TCommonMateWithParam<TProp['params'][0]>, K extends keyof T = keyof T, TIsArray extends boolean = false>(key: K, value: TIsArray extends true ? ArrayElementType<T[K]> : T[K], isArray: TIsArray): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-    decorate<T = TClass & TProp & TCommonMateWithParam<TProp['params'][0]>, K extends keyof T = keyof T, TIsArray extends boolean = false>(key: K | ((meta: T, level: TLevels, propKey?: string | symbol, index?: number) => T), value: TIsArray extends true ? ArrayElementType<T[K]> : T[K], isArray: TIsArray, level: TMergedDecoratorArgs['level']): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-    decorateConditional(ccb: (level: TLevels) => (MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator) | void | undefined): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-    decorateClass<T = TClass>(cb: ((meta: T, level: TLevels, propKey?: string | symbol, index?: number) => T)): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-    decorateClass<T = TClass, K extends keyof T = keyof T, TIsArray extends boolean = false>(key: K, value: TIsArray extends true ? ArrayElementType<T[K]> : T[K]): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-    decorateClass<T = TClass, K extends keyof T = keyof T, TIsArray extends boolean = false>(key: K, value: TIsArray extends true ? ArrayElementType<T[K]> : T[K], isArray: boolean | undefined): MethodDecorator & ClassDecorator & ParameterDecorator & PropertyDecorator;
-}
-
-declare type TAny = any;
-
-declare type TClassConstructor<T = unknown> = new (...args: TAny[]) => T;
-
-declare type TCommonMate<TParam extends TObject> = TMateClassMeta<TParam> & TMatePropMeta<TParam>;
-
-declare type TCommonMateWithParam<TParam extends TObject> = TMateClassMeta<TParam> & TMatePropMeta<TParam> & TParam;
-
-declare interface TConsoleBase {
-    error: ((...args: any) => void);
-}
-
-declare interface TEmpty {
-}
-
-declare type TFunction = Function;
-
-declare type TLevels = 'CLASS' | 'METHOD' | 'PROP' | 'PARAM';
-
-export declare interface TMateClassMeta<TParam> {
-    properties?: (string | symbol)[];
-    type?: TFunction;
-    returnType?: TFunction;
-    params?: (TParam & TMateParamMeta)[];
-}
-
-export declare interface TMateOptions<TClass extends TObject = TMateClassMeta<TMateParamMeta>, TProp extends {
-    params: TMateParamMeta[];
-} = Required<TMatePropMeta<TMateParamMeta>>> {
-    logger?: TConsoleBase;
-    readReturnType?: boolean;
-    readType?: boolean;
-    collectPropKeys?: boolean;
-    inherit?: boolean | ((classMeta: TClass & TMateClassMeta<TMateParamMeta>, targetMeta: (TMatePropMeta<TProp['params'][0]> & TProp) | (TMateParamMeta & TProp['params'][0]), level: 'CLASS' | 'PROP' | 'PARAM', key?: string) => boolean);
-}
-
-export declare interface TMateParamMeta {
-    type?: TFunction;
-}
-
-export declare interface TMatePropMeta<TParam extends TObject = TEmpty> {
-    params?: (TParam & TMateParamMeta)[];
-}
-
-export declare interface TMergedDecoratorArgs {
-    target: TFunction | TObject;
-    propKey?: string | symbol;
-    descriptor?: TypedPropertyDescriptor<TAny>;
-    index?: number;
-    level?: TLevels;
-}
-
-declare type TObject = object;
-
-export { }