@vnodes/prop 0.0.23

package/README.md

@@ -0,0 +1,35 @@
+![Npm version](https://img.shields.io/npm/v/@vnodes/prop)
+![Npm downloads](https://img.shields.io/npm/dm/@vnodes/prop)
+![Build Status](https://img.shields.io/github/actions/workflow/status/vnodes/vnodes/ci.yml)
+![Doc Status](https://img.shields.io/github/actions/workflow/status/vnodes/vnodes/doc.yml)
+![Bundle size](https://img.shields.io/bundlephobia/min/@vnodes/prop)
+
+<p align="center">
+  <img   srcset="./assets/favicon.png, https://vnodes.github.io/vnodes/libs/prop/assets/favicon.png" alt="Logo"  width="200" height="200" style="border-radius: 100%"/>
+</p>
+
+## @vnodes/prop
+
+@vnodes/prop
+
+## Installation
+
+```bash
+pnpm add @vnodes/prop
+```
+
+## 💖 Support My Work
+
+If you find my open-source contributions or the **@vnodes/prop** project helpful, consider supporting my work. Your sponsorship helps me maintain these projects and explore new enterprise patterns.
+
+[![CashApp](https://img.shields.io/badge/Sponsor%20me-%23EA4AAA.svg?style=for-the-badge&logo=github-sponsors&logoColor=white)](https://cash.app/$puqlib)
+
+---
+
+## 🤝 Connect with Me
+
+<p align="left">
+<a href="mailto:robert.brightline+vnodes-prop@gmail.com">
+<img src="https://img.shields.io/badge/Email-D14836?style=for-the-badge&logo=gmail&logoColor=white" />
+</a>
+</p>

package/bin/version.mjs

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJsonPath = join(__dirname, '..', 'package.json');
+const packageJson = readFileSync(packageJsonPath, { encoding: 'utf-8' });
+const version = JSON.parse(packageJson).version;
+console.log(version);

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export * from './lib/array-prop.js';
+export * from './lib/common-validation-pipe.js';
+export * from './lib/is-class-type.js';
+export * from './lib/is-enum-type.js';
+export * from './lib/normalize-property-options.js';
+export * from './lib/number-prop.js';
+export * from './lib/prop.js';
+export * from './lib/prop-options.js';
+export * from './lib/string-format-prop.js';
+export * from './lib/string-prop.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,qBAAqB,CAAC;AACpC,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qCAAqC,CAAC;AACpD,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC"}

package/dist/index.js

@@ -0,0 +1,13 @@
+// @index(['./**/*.ts', '!./**/*.{spec,test}.ts'], f => `export * from '${f.path}.js'`)
+export * from './lib/array-prop.js';
+export * from './lib/common-validation-pipe.js';
+export * from './lib/is-class-type.js';
+export * from './lib/is-enum-type.js';
+export * from './lib/normalize-property-options.js';
+export * from './lib/number-prop.js';
+export * from './lib/prop.js';
+export * from './lib/prop-options.js';
+export * from './lib/string-format-prop.js';
+export * from './lib/string-prop.js';
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["// @index(['./**/*.ts', '!./**/*.{spec,test}.ts'], f => `export * from '${f.path}.js'`)\nexport * from './lib/array-prop.js';\nexport * from './lib/common-validation-pipe.js';\nexport * from './lib/is-class-type.js';\nexport * from './lib/is-enum-type.js';\nexport * from './lib/normalize-property-options.js';\nexport * from './lib/number-prop.js';\nexport * from './lib/prop.js';\nexport * from './lib/prop-options.js';\nexport * from './lib/string-format-prop.js';\nexport * from './lib/string-prop.js';\n"],"names":[],"mappings":"AAAA,uFAAuF;AACvF,cAAc,sBAAsB;AACpC,cAAc,kCAAkC;AAChD,cAAc,yBAAyB;AACvC,cAAc,wBAAwB;AACtC,cAAc,sCAAsC;AACpD,cAAc,uBAAuB;AACrC,cAAc,gBAAgB;AAC9B,cAAc,wBAAwB;AACtC,cAAc,8BAA8B;AAC5C,cAAc,uBAAuB"}

package/dist/lib/array-prop.d.ts

@@ -0,0 +1,4 @@
+import { type ValidationOptions } from '@vnodes/nestjs/class-validator';
+import type { ApiPropertyOptions } from '@vnodes/nestjs/swagger';
+export declare function ArrayProp(options: ApiPropertyOptions, validationOptions?: ValidationOptions): PropertyDecorator;
+//# sourceMappingURL=array-prop.d.ts.map

package/dist/lib/array-prop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"array-prop.d.ts","sourceRoot":"","sources":["../../src/lib/array-prop.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,KAAK,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACpG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,wBAAgB,SAAS,CAAC,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,CAAC,EAAE,iBAAiB,GAAG,iBAAiB,CAkB/G"}

package/dist/lib/array-prop.js

@@ -0,0 +1,21 @@
+import { ArrayMaxSize, ArrayMinSize } from '@vnodes/nestjs/class-validator';
+export function ArrayProp(options, validationOptions) {
+    return (...args)=>{
+        const decorators = new Set();
+        const add = (...propertyDecorators)=>{
+            for (const propertyDecorator of propertyDecorators){
+                decorators.add(propertyDecorator);
+            }
+        };
+        const { minItems, maxItems } = options;
+        if (minItems) add(ArrayMinSize(minItems, validationOptions));
+        if (maxItems) add(ArrayMaxSize(maxItems, validationOptions));
+        for (const propertyDecorator of [
+            ...decorators
+        ]){
+            propertyDecorator(...args);
+        }
+    };
+}
+
+//# sourceMappingURL=array-prop.js.map

package/dist/lib/array-prop.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/array-prop.ts"],"sourcesContent":["import { ArrayMaxSize, ArrayMinSize, type ValidationOptions } from '@vnodes/nestjs/class-validator';\nimport type { ApiPropertyOptions } from '@vnodes/nestjs/swagger';\n\nexport function ArrayProp(options: ApiPropertyOptions, validationOptions?: ValidationOptions): PropertyDecorator {\n    return (...args) => {\n        const decorators: Set<PropertyDecorator> = new Set();\n        const add = (...propertyDecorators: PropertyDecorator[]) => {\n            for (const propertyDecorator of propertyDecorators) {\n                decorators.add(propertyDecorator);\n            }\n        };\n\n        const { minItems, maxItems } = options;\n\n        if (minItems) add(ArrayMinSize(minItems, validationOptions));\n        if (maxItems) add(ArrayMaxSize(maxItems, validationOptions));\n\n        for (const propertyDecorator of [...decorators]) {\n            propertyDecorator(...args);\n        }\n    };\n}\n"],"names":["ArrayMaxSize","ArrayMinSize","ArrayProp","options","validationOptions","args","decorators","Set","add","propertyDecorators","propertyDecorator","minItems","maxItems"],"mappings":"AAAA,SAASA,YAAY,EAAEC,YAAY,QAAgC,iCAAiC;AAGpG,OAAO,SAASC,UAAUC,OAA2B,EAAEC,iBAAqC;IACxF,OAAO,CAAC,GAAGC;QACP,MAAMC,aAAqC,IAAIC;QAC/C,MAAMC,MAAM,CAAC,GAAGC;YACZ,KAAK,MAAMC,qBAAqBD,mBAAoB;gBAChDH,WAAWE,GAAG,CAACE;YACnB;QACJ;QAEA,MAAM,EAAEC,QAAQ,EAAEC,QAAQ,EAAE,GAAGT;QAE/B,IAAIQ,UAAUH,IAAIP,aAAaU,UAAUP;QACzC,IAAIQ,UAAUJ,IAAIR,aAAaY,UAAUR;QAEzC,KAAK,MAAMM,qBAAqB;eAAIJ;SAAW,CAAE;YAC7CI,qBAAqBL;QACzB;IACJ;AACJ"}

package/dist/lib/common-validation-pipe.d.ts

@@ -0,0 +1,8 @@
+import type { ClassTransformOptions } from '@vnodes/nestjs/class-transformer';
+import type { ValidatorOptions } from '@vnodes/nestjs/class-validator';
+import { ValidationPipe } from '@vnodes/nestjs/common';
+export declare const __validatorOptions: ValidatorOptions;
+export declare const __transformOptions: ClassTransformOptions;
+export declare const CommonValidationPipe: ValidationPipe;
+export declare const CommonGRpcValidationPipe: ValidationPipe;
+//# sourceMappingURL=common-validation-pipe.d.ts.map

package/dist/lib/common-validation-pipe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common-validation-pipe.d.ts","sourceRoot":"","sources":["../../src/lib/common-validation-pipe.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AAC9E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAgC,cAAc,EAA8B,MAAM,uBAAuB,CAAC;AAGjH,eAAO,MAAM,kBAAkB,EAAE,gBAGhC,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,qBAGhC,CAAC;AASF,eAAO,MAAM,oBAAoB,gBAAkD,CAAC;AAEpF,eAAO,MAAM,wBAAwB,gBAKnC,CAAC"}

package/dist/lib/common-validation-pipe.js

@@ -0,0 +1,32 @@
+import { UnprocessableEntityException, ValidationPipe } from '@vnodes/nestjs/common';
+import { RpcException } from '@vnodes/nestjs/microservices';
+export const __validatorOptions = {
+    whitelist: true,
+    forbidNonWhitelisted: true
+};
+export const __transformOptions = {
+    enableImplicitConversion: true,
+    exposeUnsetFields: false
+};
+const commonValidationPipeOptions = {
+    ...__validatorOptions,
+    transformOptions: {
+        ...__transformOptions
+    },
+    exceptionFactory (errors) {
+        throw new UnprocessableEntityException({
+            errors
+        });
+    }
+};
+export const CommonValidationPipe = new ValidationPipe(commonValidationPipeOptions);
+export const CommonGRpcValidationPipe = new ValidationPipe({
+    ...commonValidationPipeOptions,
+    exceptionFactory (errors) {
+        throw new RpcException({
+            errors
+        });
+    }
+});
+
+//# sourceMappingURL=common-validation-pipe.js.map

package/dist/lib/common-validation-pipe.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/common-validation-pipe.ts"],"sourcesContent":["import type { ClassTransformOptions } from '@vnodes/nestjs/class-transformer';\nimport type { ValidatorOptions } from '@vnodes/nestjs/class-validator';\nimport { UnprocessableEntityException, ValidationPipe, type ValidationPipeOptions } from '@vnodes/nestjs/common';\nimport { RpcException } from '@vnodes/nestjs/microservices';\n\nexport const __validatorOptions: ValidatorOptions = {\n    whitelist: true,\n    forbidNonWhitelisted: true,\n};\n\nexport const __transformOptions: ClassTransformOptions = {\n    enableImplicitConversion: true,\n    exposeUnsetFields: false,\n};\n\nconst commonValidationPipeOptions: ValidationPipeOptions = {\n    ...__validatorOptions,\n    transformOptions: { ...__transformOptions },\n    exceptionFactory(errors) {\n        throw new UnprocessableEntityException({ errors });\n    },\n};\nexport const CommonValidationPipe = new ValidationPipe(commonValidationPipeOptions);\n\nexport const CommonGRpcValidationPipe = new ValidationPipe({\n    ...commonValidationPipeOptions,\n    exceptionFactory(errors) {\n        throw new RpcException({ errors });\n    },\n});\n"],"names":["UnprocessableEntityException","ValidationPipe","RpcException","__validatorOptions","whitelist","forbidNonWhitelisted","__transformOptions","enableImplicitConversion","exposeUnsetFields","commonValidationPipeOptions","transformOptions","exceptionFactory","errors","CommonValidationPipe","CommonGRpcValidationPipe"],"mappings":"AAEA,SAASA,4BAA4B,EAAEC,cAAc,QAAoC,wBAAwB;AACjH,SAASC,YAAY,QAAQ,+BAA+B;AAE5D,OAAO,MAAMC,qBAAuC;IAChDC,WAAW;IACXC,sBAAsB;AAC1B,EAAE;AAEF,OAAO,MAAMC,qBAA4C;IACrDC,0BAA0B;IAC1BC,mBAAmB;AACvB,EAAE;AAEF,MAAMC,8BAAqD;IACvD,GAAGN,kBAAkB;IACrBO,kBAAkB;QAAE,GAAGJ,kBAAkB;IAAC;IAC1CK,kBAAiBC,MAAM;QACnB,MAAM,IAAIZ,6BAA6B;YAAEY;QAAO;IACpD;AACJ;AACA,OAAO,MAAMC,uBAAuB,IAAIZ,eAAeQ,6BAA6B;AAEpF,OAAO,MAAMK,2BAA2B,IAAIb,eAAe;IACvD,GAAGQ,2BAA2B;IAC9BE,kBAAiBC,MAAM;QACnB,MAAM,IAAIV,aAAa;YAAEU;QAAO;IACpC;AACJ,GAAG"}

package/dist/lib/is-class-type.d.ts

@@ -0,0 +1,2 @@
+export declare function isClassType(type: unknown): boolean;
+//# sourceMappingURL=is-class-type.d.ts.map

package/dist/lib/is-class-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-class-type.d.ts","sourceRoot":"","sources":["../../src/lib/is-class-type.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,WAExC"}

package/dist/lib/is-class-type.js

@@ -0,0 +1,5 @@
+export function isClassType(type) {
+    return type?.constructor?.name === 'Function';
+}
+
+//# sourceMappingURL=is-class-type.js.map

package/dist/lib/is-class-type.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/is-class-type.ts"],"sourcesContent":["export function isClassType(type: unknown) {\n    return type?.constructor?.name === 'Function';\n}\n"],"names":["isClassType","type","name"],"mappings":"AAAA,OAAO,SAASA,YAAYC,IAAa;IACrC,OAAOA,MAAM,aAAaC,SAAS;AACvC"}

package/dist/lib/is-enum-type.d.ts

@@ -0,0 +1,2 @@
+export declare function isEnumType(type: object): boolean;
+//# sourceMappingURL=is-enum-type.d.ts.map

package/dist/lib/is-enum-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-enum-type.d.ts","sourceRoot":"","sources":["../../src/lib/is-enum-type.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,WAEtC"}

package/dist/lib/is-enum-type.js

@@ -0,0 +1,5 @@
+export function isEnumType(type) {
+    return type?.constructor?.name === 'Object';
+}
+
+//# sourceMappingURL=is-enum-type.js.map

package/dist/lib/is-enum-type.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/is-enum-type.ts"],"sourcesContent":["export function isEnumType(type: object) {\n    return type?.constructor?.name === 'Object';\n}\n"],"names":["isEnumType","type","name"],"mappings":"AAAA,OAAO,SAASA,WAAWC,IAAY;IACnC,OAAOA,MAAM,aAAaC,SAAS;AACvC"}

package/dist/lib/normalize-property-options.d.ts

@@ -0,0 +1,3 @@
+import type { ApiPropertyOptions } from '@vnodes/nestjs/swagger';
+export declare function normalizePropertyOptions(options: ApiPropertyOptions, target: object, propertyKey: string | symbol): ApiPropertyOptions;
+//# sourceMappingURL=normalize-property-options.d.ts.map

package/dist/lib/normalize-property-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize-property-options.d.ts","sourceRoot":"","sources":["../../src/lib/normalize-property-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAGjE,wBAAgB,wBAAwB,CACpC,OAAO,EAAE,kBAAkB,EAC3B,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAAG,MAAM,GAC7B,kBAAkB,CAsCpB"}

package/dist/lib/normalize-property-options.js

@@ -0,0 +1,37 @@
+import { isClassType } from './is-class-type.js';
+export function normalizePropertyOptions(options, target, propertyKey) {
+    if (!options) options = {};
+    if (options.required !== true) {
+        options.required = false;
+    }
+    if (options.enum) {
+        if (!Array.isArray(options.enum)) {
+            options.enum = Object.values(options.enum);
+        }
+    }
+    if (!options.type) {
+        const rtype = Reflect.getMetadata('design:type', target, propertyKey);
+        if (!rtype) {
+            throw new Error(`Could not get the reflected type from metadata!`);
+        }
+        if (rtype === String || rtype === Number || rtype === Date || rtype === Boolean) {
+            options.type = rtype;
+        } else if (rtype === Array) {
+            options.required = false;
+            if (!options.type) {
+                options.type = [
+                    String
+                ];
+                options.isArray = undefined;
+            }
+        } else if (isClassType(rtype)) {
+            options.type = rtype;
+        }
+        if (!options.type) {
+            options.type = rtype;
+        }
+    }
+    return options;
+}
+
+//# sourceMappingURL=normalize-property-options.js.map

package/dist/lib/normalize-property-options.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/normalize-property-options.ts"],"sourcesContent":["import type { ApiPropertyOptions } from '@vnodes/nestjs/swagger';\nimport { isClassType } from './is-class-type.js';\n\nexport function normalizePropertyOptions(\n    options: ApiPropertyOptions,\n    target: object,\n    propertyKey: string | symbol,\n): ApiPropertyOptions {\n    if (!options) options = {};\n\n    if (options.required !== true) {\n        options.required = false;\n    }\n\n    if (options.enum) {\n        if (!Array.isArray(options.enum)) {\n            options.enum = Object.values(options.enum);\n        }\n    }\n\n    if (!options.type) {\n        const rtype = Reflect.getMetadata('design:type', target, propertyKey);\n\n        if (!rtype) {\n            throw new Error(`Could not get the reflected type from metadata!`);\n        }\n\n        if (rtype === String || rtype === Number || rtype === Date || rtype === Boolean) {\n            options.type = rtype;\n        } else if (rtype === Array) {\n            options.required = false;\n            if (!options.type) {\n                options.type = [String];\n                options.isArray = undefined;\n            }\n        } else if (isClassType(rtype)) {\n            options.type = rtype;\n        }\n\n        if (!options.type) {\n            options.type = rtype;\n        }\n    }\n\n    return options;\n}\n"],"names":["isClassType","normalizePropertyOptions","options","target","propertyKey","required","enum","Array","isArray","Object","values","type","rtype","Reflect","getMetadata","Error","String","Number","Date","Boolean","undefined"],"mappings":"AACA,SAASA,WAAW,QAAQ,qBAAqB;AAEjD,OAAO,SAASC,yBACZC,OAA2B,EAC3BC,MAAc,EACdC,WAA4B;IAE5B,IAAI,CAACF,SAASA,UAAU,CAAC;IAEzB,IAAIA,QAAQG,QAAQ,KAAK,MAAM;QAC3BH,QAAQG,QAAQ,GAAG;IACvB;IAEA,IAAIH,QAAQI,IAAI,EAAE;QACd,IAAI,CAACC,MAAMC,OAAO,CAACN,QAAQI,IAAI,GAAG;YAC9BJ,QAAQI,IAAI,GAAGG,OAAOC,MAAM,CAACR,QAAQI,IAAI;QAC7C;IACJ;IAEA,IAAI,CAACJ,QAAQS,IAAI,EAAE;QACf,MAAMC,QAAQC,QAAQC,WAAW,CAAC,eAAeX,QAAQC;QAEzD,IAAI,CAACQ,OAAO;YACR,MAAM,IAAIG,MAAM,CAAC,+CAA+C,CAAC;QACrE;QAEA,IAAIH,UAAUI,UAAUJ,UAAUK,UAAUL,UAAUM,QAAQN,UAAUO,SAAS;YAC7EjB,QAAQS,IAAI,GAAGC;QACnB,OAAO,IAAIA,UAAUL,OAAO;YACxBL,QAAQG,QAAQ,GAAG;YACnB,IAAI,CAACH,QAAQS,IAAI,EAAE;gBACfT,QAAQS,IAAI,GAAG;oBAACK;iBAAO;gBACvBd,QAAQM,OAAO,GAAGY;YACtB;QACJ,OAAO,IAAIpB,YAAYY,QAAQ;YAC3BV,QAAQS,IAAI,GAAGC;QACnB;QAEA,IAAI,CAACV,QAAQS,IAAI,EAAE;YACfT,QAAQS,IAAI,GAAGC;QACnB;IACJ;IAEA,OAAOV;AACX"}

package/dist/lib/number-prop.d.ts

@@ -0,0 +1,4 @@
+import { type ValidatorOptions } from '@vnodes/nestjs/class-validator';
+import type { ApiPropertyOptions } from '@vnodes/nestjs/swagger';
+export declare function NumberProp(options: ApiPropertyOptions, validationOptions?: ValidatorOptions): PropertyDecorator;
+//# sourceMappingURL=number-prop.d.ts.map

package/dist/lib/number-prop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-prop.d.ts","sourceRoot":"","sources":["../../src/lib/number-prop.ts"],"names":[],"mappings":"AAAA,OAAO,EAAY,KAAK,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AACjF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,wBAAgB,UAAU,CAAC,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,CAAC,EAAE,gBAAgB,GAAG,iBAAiB,CAkB/G"}

package/dist/lib/number-prop.js

@@ -0,0 +1,21 @@
+import { Max, Min } from '@vnodes/nestjs/class-validator';
+export function NumberProp(options, validationOptions) {
+    return (...args)=>{
+        const decorators = new Set();
+        const add = (...propertyDecorators)=>{
+            for (const propertyDecorator of propertyDecorators){
+                decorators.add(propertyDecorator);
+            }
+        };
+        const { minimum, maximum } = options;
+        if (minimum !== undefined) add(Min(minimum, validationOptions));
+        if (maximum !== undefined) add(Max(maximum, validationOptions));
+        for (const propertyDecorator of [
+            ...decorators
+        ]){
+            propertyDecorator(...args);
+        }
+    };
+}
+
+//# sourceMappingURL=number-prop.js.map

package/dist/lib/number-prop.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/number-prop.ts"],"sourcesContent":["import { Max, Min, type ValidatorOptions } from '@vnodes/nestjs/class-validator';\nimport type { ApiPropertyOptions } from '@vnodes/nestjs/swagger';\n\nexport function NumberProp(options: ApiPropertyOptions, validationOptions?: ValidatorOptions): PropertyDecorator {\n    return (...args) => {\n        const decorators: Set<PropertyDecorator> = new Set();\n        const add = (...propertyDecorators: PropertyDecorator[]) => {\n            for (const propertyDecorator of propertyDecorators) {\n                decorators.add(propertyDecorator);\n            }\n        };\n\n        const { minimum, maximum } = options;\n\n        if (minimum !== undefined) add(Min(minimum, validationOptions));\n        if (maximum !== undefined) add(Max(maximum, validationOptions));\n\n        for (const propertyDecorator of [...decorators]) {\n            propertyDecorator(...args);\n        }\n    };\n}\n"],"names":["Max","Min","NumberProp","options","validationOptions","args","decorators","Set","add","propertyDecorators","propertyDecorator","minimum","maximum","undefined"],"mappings":"AAAA,SAASA,GAAG,EAAEC,GAAG,QAA+B,iCAAiC;AAGjF,OAAO,SAASC,WAAWC,OAA2B,EAAEC,iBAAoC;IACxF,OAAO,CAAC,GAAGC;QACP,MAAMC,aAAqC,IAAIC;QAC/C,MAAMC,MAAM,CAAC,GAAGC;YACZ,KAAK,MAAMC,qBAAqBD,mBAAoB;gBAChDH,WAAWE,GAAG,CAACE;YACnB;QACJ;QAEA,MAAM,EAAEC,OAAO,EAAEC,OAAO,EAAE,GAAGT;QAE7B,IAAIQ,YAAYE,WAAWL,IAAIP,IAAIU,SAASP;QAC5C,IAAIQ,YAAYC,WAAWL,IAAIR,IAAIY,SAASR;QAE5C,KAAK,MAAMM,qBAAqB;eAAIJ;SAAW,CAAE;YAC7CI,qBAAqBL;QACzB;IACJ;AACJ"}

package/dist/lib/prop-options.d.ts

@@ -0,0 +1,48 @@
+import type { ApiPropertyOptions } from '@vnodes/nestjs/swagger';
+import type { Keys } from '@vnodes/types';
+export type PropOptions = ApiPropertyOptions;
+export declare const ProOptionsMap: {
+    minItems: string;
+    type: string;
+    required: string;
+    enum: string;
+    nullable: string;
+    discriminator: string;
+    readOnly: string;
+    writeOnly: string;
+    xml: string;
+    externalDocs: string;
+    example: string;
+    examples: string;
+    deprecated: string;
+    allOf: string;
+    oneOf: string;
+    anyOf: string;
+    not: string;
+    items: string;
+    additionalProperties: string;
+    patternProperties: string;
+    description: string;
+    format: string;
+    default: string;
+    title: string;
+    multipleOf: string;
+    maximum: string;
+    exclusiveMaximum: string;
+    minimum: string;
+    exclusiveMinimum: string;
+    maxLength: string;
+    minLength: string;
+    pattern: string;
+    maxItems: string;
+    uniqueItems: string;
+    maxProperties: string;
+    minProperties: string;
+    'x-enumNames': string;
+    isArray: string;
+    name: string;
+    link: string;
+};
+export type PropOptionNames = Keys<PropOptions>;
+export declare const propOptionKeys: PropOptionNames;
+//# sourceMappingURL=prop-options.d.ts.map

package/dist/lib/prop-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prop-options.d.ts","sourceRoot":"","sources":["../../src/lib/prop-options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AACjE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C,MAAM,MAAM,WAAW,GAAG,kBAAkB,CAAC;AAE7C,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyCzB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,IAAI,CAAC,WAAW,CAAC,CAAC;AAChD,eAAO,MAAM,cAAc,EAAiC,eAAe,CAAC"}

package/dist/lib/prop-options.js

@@ -0,0 +1,45 @@
+export const ProOptionsMap = {
+    minItems: 'minItems',
+    type: 'type',
+    required: 'required',
+    enum: 'enum',
+    nullable: 'nullable',
+    discriminator: 'discriminator',
+    readOnly: 'readOnly',
+    writeOnly: 'writeOnly',
+    xml: 'xml',
+    externalDocs: 'externalDocs',
+    example: 'example',
+    examples: 'examples',
+    deprecated: 'deprecated',
+    allOf: 'allOf',
+    oneOf: 'oneOf',
+    anyOf: 'anyOf',
+    not: 'not',
+    items: 'items',
+    additionalProperties: 'additionalProperties',
+    patternProperties: 'patternProperties',
+    description: 'description',
+    format: 'format',
+    default: 'default',
+    title: 'title',
+    multipleOf: 'multipleOf',
+    maximum: 'maximum',
+    exclusiveMaximum: 'exclusiveMaximum',
+    minimum: 'minimum',
+    exclusiveMinimum: 'exclusiveMinimum',
+    maxLength: 'maxLength',
+    minLength: 'minLength',
+    pattern: 'pattern',
+    maxItems: 'maxItems',
+    uniqueItems: 'uniqueItems',
+    maxProperties: 'maxProperties',
+    minProperties: 'minProperties',
+    'x-enumNames': 'x-enumNames',
+    isArray: 'isArray',
+    name: 'name',
+    link: 'link'
+};
+export const propOptionKeys = Object.keys(ProOptionsMap);
+
+//# sourceMappingURL=prop-options.js.map

package/dist/lib/prop-options.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/prop-options.ts"],"sourcesContent":["import type { ApiPropertyOptions } from '@vnodes/nestjs/swagger';\nimport type { Keys } from '@vnodes/types';\n\nexport type PropOptions = ApiPropertyOptions;\n\nexport const ProOptionsMap = {\n    minItems: 'minItems',\n    type: 'type',\n    required: 'required',\n    enum: 'enum',\n    nullable: 'nullable',\n    discriminator: 'discriminator',\n    readOnly: 'readOnly',\n    writeOnly: 'writeOnly',\n    xml: 'xml',\n    externalDocs: 'externalDocs',\n    example: 'example',\n    examples: 'examples',\n    deprecated: 'deprecated',\n    allOf: 'allOf',\n    oneOf: 'oneOf',\n    anyOf: 'anyOf',\n    not: 'not',\n    items: 'items',\n    additionalProperties: 'additionalProperties',\n    patternProperties: 'patternProperties',\n    description: 'description',\n    format: 'format',\n    default: 'default',\n    title: 'title',\n    multipleOf: 'multipleOf',\n    maximum: 'maximum',\n    exclusiveMaximum: 'exclusiveMaximum',\n    minimum: 'minimum',\n    exclusiveMinimum: 'exclusiveMinimum',\n    maxLength: 'maxLength',\n    minLength: 'minLength',\n    pattern: 'pattern',\n    maxItems: 'maxItems',\n    uniqueItems: 'uniqueItems',\n    maxProperties: 'maxProperties',\n    minProperties: 'minProperties',\n    'x-enumNames': 'x-enumNames',\n    isArray: 'isArray',\n    name: 'name',\n    link: 'link',\n};\n\nexport type PropOptionNames = Keys<PropOptions>;\nexport const propOptionKeys = Object.keys(ProOptionsMap) as PropOptionNames;\n"],"names":["ProOptionsMap","minItems","type","required","enum","nullable","discriminator","readOnly","writeOnly","xml","externalDocs","example","examples","deprecated","allOf","oneOf","anyOf","not","items","additionalProperties","patternProperties","description","format","default","title","multipleOf","maximum","exclusiveMaximum","minimum","exclusiveMinimum","maxLength","minLength","pattern","maxItems","uniqueItems","maxProperties","minProperties","isArray","name","link","propOptionKeys","Object","keys"],"mappings":"AAKA,OAAO,MAAMA,gBAAgB;IACzBC,UAAU;IACVC,MAAM;IACNC,UAAU;IACVC,MAAM;IACNC,UAAU;IACVC,eAAe;IACfC,UAAU;IACVC,WAAW;IACXC,KAAK;IACLC,cAAc;IACdC,SAAS;IACTC,UAAU;IACVC,YAAY;IACZC,OAAO;IACPC,OAAO;IACPC,OAAO;IACPC,KAAK;IACLC,OAAO;IACPC,sBAAsB;IACtBC,mBAAmB;IACnBC,aAAa;IACbC,QAAQ;IACRC,SAAS;IACTC,OAAO;IACPC,YAAY;IACZC,SAAS;IACTC,kBAAkB;IAClBC,SAAS;IACTC,kBAAkB;IAClBC,WAAW;IACXC,WAAW;IACXC,SAAS;IACTC,UAAU;IACVC,aAAa;IACbC,eAAe;IACfC,eAAe;IACf,eAAe;IACfC,SAAS;IACTC,MAAM;IACNC,MAAM;AACV,EAAE;AAGF,OAAO,MAAMC,iBAAiBC,OAAOC,IAAI,CAAC1C,eAAkC"}

package/dist/lib/prop.d.ts

@@ -0,0 +1,24 @@
+import { type ValidationOptions } from '@vnodes/nestjs/class-validator';
+import type { PropOptions } from './prop-options.js';
+/**
+ * ## Examples
+ * ```typescript
+ *   \@Prop() value: string;
+ *   \@Prop() value: number;
+ *   \@Prop() value: boolean;
+ *   \@Prop() value: Date;
+ *   \@Prop({ type: CustomObject }) value: CustomObject;
+ *   \@Prop({ type: [String] }) value: string[];
+ *   \@Prop({ enum: EnumClss }) value: EnumClss;
+ *   \@Prop({ type:[EnumClss] enum: EnumClss }) value: EnumClss;
+ *
+ * ## Notes
+ * - properties are optional by defualt if required is not set true
+ * ```
+ * @param options Open api property options
+ * @param validationOptions property validation options from class-validator
+ * @returns -- {@link PropertyDecorator}
+ */
+export declare function Prop(options?: PropOptions, validationOptions?: ValidationOptions): PropertyDecorator;
+export declare function OptionalProp(options?: PropOptions, validationOptions?: ValidationOptions): PropertyDecorator;
+//# sourceMappingURL=prop.d.ts.map

package/dist/lib/prop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prop.d.ts","sourceRoot":"","sources":["../../src/lib/prop.ts"],"names":[],"mappings":"AACA,OAAO,EAOH,KAAK,iBAAiB,EACzB,MAAM,gCAAgC,CAAC;AAOxC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,IAAI,CAAC,OAAO,GAAE,WAAgB,EAAE,iBAAiB,CAAC,EAAE,iBAAiB,GAAG,iBAAiB,CAuDxG;AAED,wBAAgB,YAAY,CAAC,OAAO,GAAE,WAAgB,EAAE,iBAAiB,CAAC,EAAE,iBAAiB,GAAG,iBAAiB,CAUhH"}

package/dist/lib/prop.js

@@ -0,0 +1,98 @@
+import { Expose, Type } from '@vnodes/nestjs/class-transformer';
+import { IsBoolean, IsDate, IsDefined, IsEnum, IsOptional, ValidateNested } from '@vnodes/nestjs/class-validator';
+import { ApiProperty } from '@vnodes/nestjs/swagger';
+import { ArrayProp } from './array-prop.js';
+import { isClassType } from './is-class-type.js';
+import { normalizePropertyOptions } from './normalize-property-options.js';
+import { NumberProp } from './number-prop.js';
+import { StringProp } from './string-prop.js';
+/**
+ * ## Examples
+ * ```typescript
+ *   \@Prop() value: string;
+ *   \@Prop() value: number;
+ *   \@Prop() value: boolean;
+ *   \@Prop() value: Date;
+ *   \@Prop({ type: CustomObject }) value: CustomObject;
+ *   \@Prop({ type: [String] }) value: string[];
+ *   \@Prop({ enum: EnumClss }) value: EnumClss;
+ *   \@Prop({ type:[EnumClss] enum: EnumClss }) value: EnumClss;
+ *
+ * ## Notes
+ * - properties are optional by defualt if required is not set true
+ * ```
+ * @param options Open api property options
+ * @param validationOptions property validation options from class-validator
+ * @returns -- {@link PropertyDecorator}
+ */ export function Prop(options = {}, validationOptions) {
+    return (...args)=>{
+        options = normalizePropertyOptions(options, args[0], args[1]);
+        const safeType = options.type;
+        const decorators = new Set();
+        const add = (...propertyDecorators)=>{
+            for (const propertyDecorator of propertyDecorators){
+                decorators.add(propertyDecorator);
+            }
+        };
+        if (options.enum) {
+            if (!Array.isArray(options.enum)) {
+                options.enum = Object.values(options.enum);
+            }
+            add(IsEnum(options.enum, {
+                ...validationOptions,
+                message: `$property should be one of ${options.enum}`
+            }));
+        }
+        if (Array.isArray(options.type)) {
+            add(ArrayProp(options, validationOptions));
+            add(Prop({
+                ...options.items,
+                type: options.type[0]
+            }, {
+                each: true
+            }));
+        } else if (options.type === String) {
+            add(StringProp(options, validationOptions));
+        } else if (options.type === Number) {
+            add(NumberProp(options, validationOptions));
+        } else if (options.type === Boolean) {
+            add(IsBoolean(validationOptions));
+        } else if (options.type === Date) {
+            add(IsDate(validationOptions));
+        } else if (isClassType(options.type)) {
+            options.type = new options.type();
+            add(Type(()=>options.type));
+            add(ValidateNested(validationOptions));
+        } else if (typeof options.type === 'function') {
+            add(Type(options.type));
+            add(ValidateNested(validationOptions));
+        }
+        if (!validationOptions) {
+            add(ApiProperty({
+                ...options,
+                type: safeType
+            }));
+            add(Expose());
+            if (options.required === true) {
+                add(IsDefined(validationOptions));
+            } else {
+                add(IsOptional(validationOptions));
+            }
+        }
+        for (const decorator of [
+            ...decorators
+        ]){
+            decorator(...args);
+        }
+    };
+}
+export function OptionalProp(options = {}, validationOptions) {
+    return (...args)=>{
+        Prop({
+            ...options,
+            required: false
+        }, validationOptions)(...args);
+    };
+}
+
+//# sourceMappingURL=prop.js.map

package/dist/lib/prop.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/prop.ts"],"sourcesContent":["import { type ClassConstructor, Expose, Type } from '@vnodes/nestjs/class-transformer';\nimport {\n    IsBoolean,\n    IsDate,\n    IsDefined,\n    IsEnum,\n    IsOptional,\n    ValidateNested,\n    type ValidationOptions,\n} from '@vnodes/nestjs/class-validator';\nimport { type ApiPropertyOptions as __ApiPropertyOptions, ApiProperty } from '@vnodes/nestjs/swagger';\nimport type { Any } from '@vnodes/types';\nimport { ArrayProp } from './array-prop.js';\nimport { isClassType } from './is-class-type.js';\nimport { normalizePropertyOptions } from './normalize-property-options.js';\nimport { NumberProp } from './number-prop.js';\nimport type { PropOptions } from './prop-options.js';\nimport { StringProp } from './string-prop.js';\n\n/**\n * ## Examples\n * ```typescript\n *   \\@Prop() value: string;\n *   \\@Prop() value: number;\n *   \\@Prop() value: boolean;\n *   \\@Prop() value: Date;\n *   \\@Prop({ type: CustomObject }) value: CustomObject;\n *   \\@Prop({ type: [String] }) value: string[];\n *   \\@Prop({ enum: EnumClss }) value: EnumClss;\n *   \\@Prop({ type:[EnumClss] enum: EnumClss }) value: EnumClss;\n *\n * ## Notes\n * - properties are optional by defualt if required is not set true\n * ```\n * @param options Open api property options\n * @param validationOptions property validation options from class-validator\n * @returns -- {@link PropertyDecorator}\n */\nexport function Prop(options: PropOptions = {}, validationOptions?: ValidationOptions): PropertyDecorator {\n    return (...args) => {\n        options = normalizePropertyOptions(options, args[0], args[1]);\n\n        const safeType = options.type;\n\n        const decorators = new Set<PropertyDecorator>();\n        const add = (...propertyDecorators: PropertyDecorator[]) => {\n            for (const propertyDecorator of propertyDecorators) {\n                decorators.add(propertyDecorator);\n            }\n        };\n\n        if (options.enum) {\n            if (!Array.isArray(options.enum)) {\n                options.enum = Object.values(options.enum);\n            }\n            add(IsEnum(options.enum, { ...validationOptions, message: `$property should be one of ${options.enum}` }));\n        }\n\n        if (Array.isArray(options.type)) {\n            add(ArrayProp(options, validationOptions));\n            add(Prop({ ...options.items, type: options.type[0] } as Any, { each: true }));\n        } else if (options.type === String) {\n            add(StringProp(options, validationOptions));\n        } else if (options.type === Number) {\n            add(NumberProp(options, validationOptions));\n        } else if (options.type === Boolean) {\n            add(IsBoolean(validationOptions));\n        } else if (options.type === Date) {\n            add(IsDate(validationOptions));\n        } else if (isClassType(options.type)) {\n            options.type = new (options.type as Any)();\n            add(Type(() => options.type as ClassConstructor<unknown>));\n            add(ValidateNested(validationOptions));\n        } else if (typeof options.type === 'function') {\n            add(Type(options.type as () => ClassConstructor<Any>));\n            add(ValidateNested(validationOptions));\n        }\n\n        if (!validationOptions) {\n            add(ApiProperty({ ...options, type: safeType } as __ApiPropertyOptions));\n            add(Expose());\n\n            if (options.required === true) {\n                add(IsDefined(validationOptions));\n            } else {\n                add(IsOptional(validationOptions));\n            }\n        }\n\n        for (const decorator of [...decorators]) {\n            decorator(...args);\n        }\n    };\n}\n\nexport function OptionalProp(options: PropOptions = {}, validationOptions?: ValidationOptions): PropertyDecorator {\n    return (...args) => {\n        Prop(\n            {\n                ...options,\n                required: false,\n            } as PropOptions,\n            validationOptions,\n        )(...args);\n    };\n}\n"],"names":["Expose","Type","IsBoolean","IsDate","IsDefined","IsEnum","IsOptional","ValidateNested","ApiProperty","ArrayProp","isClassType","normalizePropertyOptions","NumberProp","StringProp","Prop","options","validationOptions","args","safeType","type","decorators","Set","add","propertyDecorators","propertyDecorator","enum","Array","isArray","Object","values","message","items","each","String","Number","Boolean","Date","required","decorator","OptionalProp"],"mappings":"AAAA,SAAgCA,MAAM,EAAEC,IAAI,QAAQ,mCAAmC;AACvF,SACIC,SAAS,EACTC,MAAM,EACNC,SAAS,EACTC,MAAM,EACNC,UAAU,EACVC,cAAc,QAEX,iCAAiC;AACxC,SAA0DC,WAAW,QAAQ,yBAAyB;AAEtG,SAASC,SAAS,QAAQ,kBAAkB;AAC5C,SAASC,WAAW,QAAQ,qBAAqB;AACjD,SAASC,wBAAwB,QAAQ,kCAAkC;AAC3E,SAASC,UAAU,QAAQ,mBAAmB;AAE9C,SAASC,UAAU,QAAQ,mBAAmB;AAE9C;;;;;;;;;;;;;;;;;;CAkBC,GACD,OAAO,SAASC,KAAKC,UAAuB,CAAC,CAAC,EAAEC,iBAAqC;IACjF,OAAO,CAAC,GAAGC;QACPF,UAAUJ,yBAAyBI,SAASE,IAAI,CAAC,EAAE,EAAEA,IAAI,CAAC,EAAE;QAE5D,MAAMC,WAAWH,QAAQI,IAAI;QAE7B,MAAMC,aAAa,IAAIC;QACvB,MAAMC,MAAM,CAAC,GAAGC;YACZ,KAAK,MAAMC,qBAAqBD,mBAAoB;gBAChDH,WAAWE,GAAG,CAACE;YACnB;QACJ;QAEA,IAAIT,QAAQU,IAAI,EAAE;YACd,IAAI,CAACC,MAAMC,OAAO,CAACZ,QAAQU,IAAI,GAAG;gBAC9BV,QAAQU,IAAI,GAAGG,OAAOC,MAAM,CAACd,QAAQU,IAAI;YAC7C;YACAH,IAAIjB,OAAOU,QAAQU,IAAI,EAAE;gBAAE,GAAGT,iBAAiB;gBAAEc,SAAS,CAAC,2BAA2B,EAAEf,QAAQU,IAAI,EAAE;YAAC;QAC3G;QAEA,IAAIC,MAAMC,OAAO,CAACZ,QAAQI,IAAI,GAAG;YAC7BG,IAAIb,UAAUM,SAASC;YACvBM,IAAIR,KAAK;gBAAE,GAAGC,QAAQgB,KAAK;gBAAEZ,MAAMJ,QAAQI,IAAI,CAAC,EAAE;YAAC,GAAU;gBAAEa,MAAM;YAAK;QAC9E,OAAO,IAAIjB,QAAQI,IAAI,KAAKc,QAAQ;YAChCX,IAAIT,WAAWE,SAASC;QAC5B,OAAO,IAAID,QAAQI,IAAI,KAAKe,QAAQ;YAChCZ,IAAIV,WAAWG,SAASC;QAC5B,OAAO,IAAID,QAAQI,IAAI,KAAKgB,SAAS;YACjCb,IAAIpB,UAAUc;QAClB,OAAO,IAAID,QAAQI,IAAI,KAAKiB,MAAM;YAC9Bd,IAAInB,OAAOa;QACf,OAAO,IAAIN,YAAYK,QAAQI,IAAI,GAAG;YAClCJ,QAAQI,IAAI,GAAG,IAAKJ,QAAQI,IAAI;YAChCG,IAAIrB,KAAK,IAAMc,QAAQI,IAAI;YAC3BG,IAAIf,eAAeS;QACvB,OAAO,IAAI,OAAOD,QAAQI,IAAI,KAAK,YAAY;YAC3CG,IAAIrB,KAAKc,QAAQI,IAAI;YACrBG,IAAIf,eAAeS;QACvB;QAEA,IAAI,CAACA,mBAAmB;YACpBM,IAAId,YAAY;gBAAE,GAAGO,OAAO;gBAAEI,MAAMD;YAAS;YAC7CI,IAAItB;YAEJ,IAAIe,QAAQsB,QAAQ,KAAK,MAAM;gBAC3Bf,IAAIlB,UAAUY;YAClB,OAAO;gBACHM,IAAIhB,WAAWU;YACnB;QACJ;QAEA,KAAK,MAAMsB,aAAa;eAAIlB;SAAW,CAAE;YACrCkB,aAAarB;QACjB;IACJ;AACJ;AAEA,OAAO,SAASsB,aAAaxB,UAAuB,CAAC,CAAC,EAAEC,iBAAqC;IACzF,OAAO,CAAC,GAAGC;QACPH,KACI;YACI,GAAGC,OAAO;YACVsB,UAAU;QACd,GACArB,sBACCC;IACT;AACJ"}

package/dist/lib/string-format-prop.d.ts

@@ -0,0 +1,4 @@
+import { type ValidatorOptions } from '@vnodes/nestjs/class-validator';
+import type { ApiPropertyOptions } from '@vnodes/nestjs/swagger';
+export declare function StringFormatProp(options: ApiPropertyOptions, validationOptions?: ValidatorOptions): PropertyDecorator;
+//# sourceMappingURL=string-format-prop.d.ts.map

package/dist/lib/string-format-prop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-format-prop.d.ts","sourceRoot":"","sources":["../../src/lib/string-format-prop.ts"],"names":[],"mappings":"AAAA,OAAO,EAUH,KAAK,gBAAgB,EACxB,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAEjE,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,CAAC,EAAE,gBAAgB,GAAG,iBAAiB,CAgGrH"}

package/dist/lib/string-format-prop.js

@@ -0,0 +1,99 @@
+import { IsEmail, IsFQDN, IsIP, IsISO8601, IsNumberString, IsStrongPassword, IsUrl, IsUUID, Matches } from '@vnodes/nestjs/class-validator';
+export function StringFormatProp(options, validationOptions) {
+    return (...args)=>{
+        const { format } = options;
+        const decorators = new Set();
+        const add = (...propertyDecorators)=>{
+            for (const propertyDecorator of propertyDecorators){
+                decorators.add(propertyDecorator);
+            }
+        };
+        switch(format){
+            case 'hostname':
+                {
+                    add(IsFQDN({}, validationOptions));
+                    break;
+                }
+            case 'duration':
+                {
+                    add(Matches(/^P(?!$)((\d+Y)?(\d+M)?(\d+W)?(\d+D)?)(T(?=\d)(\d+H)?(\d+M)?(\d+S)?)?$/, {
+                        ...validationOptions,
+                        message: '$property must be a valid duration'
+                    }));
+                    break;
+                }
+            case 'password':
+                {
+                    add(IsStrongPassword({
+                        minLength: 6,
+                        minLowercase: 1,
+                        minNumbers: 1,
+                        minSymbols: 1,
+                        minUppercase: 1
+                    }, validationOptions));
+                    break;
+                }
+            case 'email':
+                {
+                    add(IsEmail({}, validationOptions));
+                    break;
+                }
+            case 'time':
+            case 'date-time':
+            case 'date':
+                {
+                    add(IsISO8601({}, validationOptions));
+                    break;
+                }
+            case 'binary':
+                {
+                    add(Matches(/^[0-1]{1,}$/, validationOptions));
+                    break;
+                }
+            case 'int32':
+            case 'int64':
+            case 'float':
+            case 'double':
+                {
+                    add(IsNumberString({}, validationOptions));
+                    break;
+                }
+            case 'uri-reference':
+            case 'uri-template':
+            case 'uri':
+                {
+                    add(IsUrl({
+                        allow_fragments: true,
+                        require_tld: false,
+                        allow_protocol_relative_urls: true,
+                        allow_query_components: true,
+                        allow_trailing_dot: true,
+                        allow_underscores: true
+                    }, validationOptions));
+                    break;
+                }
+            case 'ipv4':
+                {
+                    add(IsIP('4', validationOptions));
+                    break;
+                }
+            case 'ipv6':
+                {
+                    add(IsIP('6', validationOptions));
+                    break;
+                }
+            case 'uuid':
+                {
+                    add(IsUUID('all', validationOptions));
+                    break;
+                }
+        }
+        for (const propertyDecorator of [
+            ...decorators
+        ]){
+            propertyDecorator(...args);
+        }
+    };
+}
+
+//# sourceMappingURL=string-format-prop.js.map

package/dist/lib/string-format-prop.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/string-format-prop.ts"],"sourcesContent":["import {\n    IsEmail,\n    IsFQDN,\n    IsIP,\n    IsISO8601,\n    IsNumberString,\n    IsStrongPassword,\n    IsUrl,\n    IsUUID,\n    Matches,\n    type ValidatorOptions,\n} from '@vnodes/nestjs/class-validator';\nimport type { ApiPropertyOptions } from '@vnodes/nestjs/swagger';\n\nexport function StringFormatProp(options: ApiPropertyOptions, validationOptions?: ValidatorOptions): PropertyDecorator {\n    return (...args) => {\n        const { format } = options;\n        const decorators: Set<PropertyDecorator> = new Set();\n        const add = (...propertyDecorators: PropertyDecorator[]) => {\n            for (const propertyDecorator of propertyDecorators) {\n                decorators.add(propertyDecorator);\n            }\n        };\n\n        switch (format) {\n            case 'hostname': {\n                add(IsFQDN({}, validationOptions));\n                break;\n            }\n            case 'duration': {\n                add(\n                    Matches(/^P(?!$)((\\d+Y)?(\\d+M)?(\\d+W)?(\\d+D)?)(T(?=\\d)(\\d+H)?(\\d+M)?(\\d+S)?)?$/, {\n                        ...validationOptions,\n                        message: '$property must be a valid duration',\n                    }),\n                );\n                break;\n            }\n            case 'password': {\n                add(\n                    IsStrongPassword(\n                        {\n                            minLength: 6,\n                            minLowercase: 1,\n                            minNumbers: 1,\n                            minSymbols: 1,\n                            minUppercase: 1,\n                        },\n                        validationOptions,\n                    ),\n                );\n                break;\n            }\n            case 'email': {\n                add(IsEmail({}, validationOptions));\n                break;\n            }\n            case 'time':\n            case 'date-time':\n            case 'date': {\n                add(IsISO8601({}, validationOptions));\n                break;\n            }\n            case 'binary': {\n                add(Matches(/^[0-1]{1,}$/, validationOptions));\n                break;\n            }\n            case 'int32':\n            case 'int64':\n            case 'float':\n            case 'double': {\n                add(IsNumberString({}, validationOptions));\n                break;\n            }\n            case 'uri-reference':\n            case 'uri-template':\n            case 'uri': {\n                add(\n                    IsUrl(\n                        {\n                            allow_fragments: true,\n                            require_tld: false,\n                            allow_protocol_relative_urls: true,\n                            allow_query_components: true,\n                            allow_trailing_dot: true,\n                            allow_underscores: true,\n                        },\n                        validationOptions,\n                    ),\n                );\n                break;\n            }\n            case 'ipv4': {\n                add(IsIP('4', validationOptions));\n                break;\n            }\n            case 'ipv6': {\n                add(IsIP('6', validationOptions));\n                break;\n            }\n            case 'uuid': {\n                add(IsUUID('all', validationOptions));\n                break;\n            }\n        }\n\n        for (const propertyDecorator of [...decorators]) {\n            propertyDecorator(...args);\n        }\n    };\n}\n"],"names":["IsEmail","IsFQDN","IsIP","IsISO8601","IsNumberString","IsStrongPassword","IsUrl","IsUUID","Matches","StringFormatProp","options","validationOptions","args","format","decorators","Set","add","propertyDecorators","propertyDecorator","message","minLength","minLowercase","minNumbers","minSymbols","minUppercase","allow_fragments","require_tld","allow_protocol_relative_urls","allow_query_components","allow_trailing_dot","allow_underscores"],"mappings":"AAAA,SACIA,OAAO,EACPC,MAAM,EACNC,IAAI,EACJC,SAAS,EACTC,cAAc,EACdC,gBAAgB,EAChBC,KAAK,EACLC,MAAM,EACNC,OAAO,QAEJ,iCAAiC;AAGxC,OAAO,SAASC,iBAAiBC,OAA2B,EAAEC,iBAAoC;IAC9F,OAAO,CAAC,GAAGC;QACP,MAAM,EAAEC,MAAM,EAAE,GAAGH;QACnB,MAAMI,aAAqC,IAAIC;QAC/C,MAAMC,MAAM,CAAC,GAAGC;YACZ,KAAK,MAAMC,qBAAqBD,mBAAoB;gBAChDH,WAAWE,GAAG,CAACE;YACnB;QACJ;QAEA,OAAQL;YACJ,KAAK;gBAAY;oBACbG,IAAIf,OAAO,CAAC,GAAGU;oBACf;gBACJ;YACA,KAAK;gBAAY;oBACbK,IACIR,QAAQ,yEAAyE;wBAC7E,GAAGG,iBAAiB;wBACpBQ,SAAS;oBACb;oBAEJ;gBACJ;YACA,KAAK;gBAAY;oBACbH,IACIX,iBACI;wBACIe,WAAW;wBACXC,cAAc;wBACdC,YAAY;wBACZC,YAAY;wBACZC,cAAc;oBAClB,GACAb;oBAGR;gBACJ;YACA,KAAK;gBAAS;oBACVK,IAAIhB,QAAQ,CAAC,GAAGW;oBAChB;gBACJ;YACA,KAAK;YACL,KAAK;YACL,KAAK;gBAAQ;oBACTK,IAAIb,UAAU,CAAC,GAAGQ;oBAClB;gBACJ;YACA,KAAK;gBAAU;oBACXK,IAAIR,QAAQ,eAAeG;oBAC3B;gBACJ;YACA,KAAK;YACL,KAAK;YACL,KAAK;YACL,KAAK;gBAAU;oBACXK,IAAIZ,eAAe,CAAC,GAAGO;oBACvB;gBACJ;YACA,KAAK;YACL,KAAK;YACL,KAAK;gBAAO;oBACRK,IACIV,MACI;wBACImB,iBAAiB;wBACjBC,aAAa;wBACbC,8BAA8B;wBAC9BC,wBAAwB;wBACxBC,oBAAoB;wBACpBC,mBAAmB;oBACvB,GACAnB;oBAGR;gBACJ;YACA,KAAK;gBAAQ;oBACTK,IAAId,KAAK,KAAKS;oBACd;gBACJ;YACA,KAAK;gBAAQ;oBACTK,IAAId,KAAK,KAAKS;oBACd;gBACJ;YACA,KAAK;gBAAQ;oBACTK,IAAIT,OAAO,OAAOI;oBAClB;gBACJ;QACJ;QAEA,KAAK,MAAMO,qBAAqB;eAAIJ;SAAW,CAAE;YAC7CI,qBAAqBN;QACzB;IACJ;AACJ"}

package/dist/lib/string-prop.d.ts

@@ -0,0 +1,4 @@
+import { type ValidationOptions } from '@vnodes/nestjs/class-validator';
+import type { ApiPropertyOptions } from '@vnodes/nestjs/swagger';
+export declare function StringProp(options: ApiPropertyOptions, validationOptions?: ValidationOptions): PropertyDecorator;
+//# sourceMappingURL=string-prop.d.ts.map

package/dist/lib/string-prop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-prop.d.ts","sourceRoot":"","sources":["../../src/lib/string-prop.ts"],"names":[],"mappings":"AAAA,OAAO,EAMH,KAAK,iBAAiB,EACzB,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAGjE,wBAAgB,UAAU,CAAC,OAAO,EAAE,kBAAkB,EAAE,iBAAiB,CAAC,EAAE,iBAAiB,GAAG,iBAAiB,CA2BhH"}

package/dist/lib/string-prop.js

@@ -0,0 +1,28 @@
+import { IsNotEmpty, IsString, Matches, MaxLength, MinLength } from '@vnodes/nestjs/class-validator';
+import { StringFormatProp } from './string-format-prop.js';
+export function StringProp(options, validationOptions) {
+    return (...args)=>{
+        const decorators = new Set();
+        const add = (...propertyDecorators)=>{
+            for (const propertyDecorator of propertyDecorators){
+                decorators.add(propertyDecorator);
+            }
+        };
+        const { format, minLength, maxLength, pattern } = options;
+        add(IsString(validationOptions));
+        if (options.required === true) {
+            add(IsNotEmpty(validationOptions));
+        }
+        if (format) add(StringFormatProp(options, validationOptions));
+        if (minLength) add(MinLength(minLength, validationOptions));
+        if (maxLength) add(MaxLength(maxLength, validationOptions));
+        if (pattern) add(Matches(pattern, undefined, validationOptions));
+        for (const propertyDecorator of [
+            ...decorators
+        ]){
+            propertyDecorator(...args);
+        }
+    };
+}
+
+//# sourceMappingURL=string-prop.js.map

package/dist/lib/string-prop.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/string-prop.ts"],"sourcesContent":["import {\n    IsNotEmpty,\n    IsString,\n    Matches,\n    MaxLength,\n    MinLength,\n    type ValidationOptions,\n} from '@vnodes/nestjs/class-validator';\nimport type { ApiPropertyOptions } from '@vnodes/nestjs/swagger';\nimport { StringFormatProp } from './string-format-prop.js';\n\nexport function StringProp(options: ApiPropertyOptions, validationOptions?: ValidationOptions): PropertyDecorator {\n    return (...args) => {\n        const decorators: Set<PropertyDecorator> = new Set();\n        const add = (...propertyDecorators: PropertyDecorator[]) => {\n            for (const propertyDecorator of propertyDecorators) {\n                decorators.add(propertyDecorator);\n            }\n        };\n\n        const { format, minLength, maxLength, pattern } = options;\n\n        add(IsString(validationOptions));\n\n        if (options.required === true) {\n            add(IsNotEmpty(validationOptions));\n        }\n\n        if (format) add(StringFormatProp(options, validationOptions));\n\n        if (minLength) add(MinLength(minLength, validationOptions));\n        if (maxLength) add(MaxLength(maxLength, validationOptions));\n        if (pattern) add(Matches(pattern, undefined, validationOptions));\n\n        for (const propertyDecorator of [...decorators]) {\n            propertyDecorator(...args);\n        }\n    };\n}\n"],"names":["IsNotEmpty","IsString","Matches","MaxLength","MinLength","StringFormatProp","StringProp","options","validationOptions","args","decorators","Set","add","propertyDecorators","propertyDecorator","format","minLength","maxLength","pattern","required","undefined"],"mappings":"AAAA,SACIA,UAAU,EACVC,QAAQ,EACRC,OAAO,EACPC,SAAS,EACTC,SAAS,QAEN,iCAAiC;AAExC,SAASC,gBAAgB,QAAQ,0BAA0B;AAE3D,OAAO,SAASC,WAAWC,OAA2B,EAAEC,iBAAqC;IACzF,OAAO,CAAC,GAAGC;QACP,MAAMC,aAAqC,IAAIC;QAC/C,MAAMC,MAAM,CAAC,GAAGC;YACZ,KAAK,MAAMC,qBAAqBD,mBAAoB;gBAChDH,WAAWE,GAAG,CAACE;YACnB;QACJ;QAEA,MAAM,EAAEC,MAAM,EAAEC,SAAS,EAAEC,SAAS,EAAEC,OAAO,EAAE,GAAGX;QAElDK,IAAIX,SAASO;QAEb,IAAID,QAAQY,QAAQ,KAAK,MAAM;YAC3BP,IAAIZ,WAAWQ;QACnB;QAEA,IAAIO,QAAQH,IAAIP,iBAAiBE,SAASC;QAE1C,IAAIQ,WAAWJ,IAAIR,UAAUY,WAAWR;QACxC,IAAIS,WAAWL,IAAIT,UAAUc,WAAWT;QACxC,IAAIU,SAASN,IAAIV,QAAQgB,SAASE,WAAWZ;QAE7C,KAAK,MAAMM,qBAAqB;eAAIJ;SAAW,CAAE;YAC7CI,qBAAqBL;QACzB;IACJ;AACJ"}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@vnodes/prop",
+  "version": "0.0.23",
+  "description": "@vnodes/prop",
+  "keywords": [
+    "prop"
+  ],
+  "author": {
+    "name": "Robert Brightline",
+    "email": "robert.brightline+vnodes-prop@gmail.com",
+    "url": "https://vnodes.github.io/vnodes"
+  },
+  "homepage": "https://vnodes.github.io/vnodes/libs/prop",
+  "icon": "https://vnodes.github.io/vnodes/libs/prop/assets/favicon.png",
+  "funding": [
+    "https://cash.app/$puqlib"
+  ],
+  "bin": {
+    "version": "./bin/version.mjs"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "@vnodes/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "bin",
+    "!**/*.tsbuildinfo"
+  ],
+  "nx": {
+    "sourceRoot": "libs/prop/src",
+    "targets": {
+      "build": {},
+      "doc": {},
+      "lint": {}
+    },
+    "tags": [
+      "lib"
+    ]
+  },
+  "dependencies": {
+    "@swc/helpers": "~0.5.18"
+  },
+  "peerDependencies": {
+    "@vnodes/nestjs": "0.0.23",
+    "@vnodes/types": "0.0.23"
+  },
+  "devDependencies": {
+    "@vnodes/nestjs": "0.0.23",
+    "@vnodes/types": "0.0.23"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "latest"
+  }
+}