@innet/server 1.7.1 → 2.0.0-alpha.1

package/plugins/schema/object/object.d.ts

@@ -0,0 +1,5 @@
+import { type HandlerPlugin } from 'innet';
+import { type BaseSchemaProps } from '../../../types';
+export interface ObjectProps extends BaseSchemaProps<object> {
+}
+export declare const object: HandlerPlugin;

package/plugins/schema/object/object.es6.js

@@ -0,0 +1,54 @@
+import innet, { useNewHandler } from 'innet';
+import { useChildren, useProps } from '@innet/jsx';
+import '../../../hooks/index.es6.js';
+import '../../../hooks/useParentRule/index.es6.js';
+import '../../../utils/index.es6.js';
+import { useBlock } from '../../../hooks/useBlock/useBlock.es6.js';
+import { useApi } from '../../../hooks/useApi/useApi.es6.js';
+import { useSchemaType } from '../../../hooks/useSchemaType/useSchemaType.es6.js';
+import { schemaContext } from '../../../hooks/useSchemaContext/useSchemaContext.es6.js';
+import { parentRuleContext, useParentRule } from '../../../hooks/useParentRule/useParentRule.es6.js';
+import { defaultTo } from '../../../utils/rules/defaultTo/defaultTo.es6.js';
+import { objectOf } from '../../../utils/rules/objectOf/objectOf.es6.js';
+import { pipe } from '../../../utils/rules/pipe/pipe.es6.js';
+import { useRule, ruleContext } from '../../../hooks/useRule/useRule.es6.js';
+import { objectRuleContext } from '../../../hooks/useObjectRule/useObjectRule.es6.js';
+
+const object = () => {
+    useBlock('path');
+    const children = useChildren();
+    const props = useProps() || {};
+    const { refRules } = useApi();
+    const schema = useSchemaType('object', props);
+    const handler = useNewHandler();
+    if (schema) {
+        schemaContext.set(handler, schema);
+        parentRuleContext.reset(handler);
+        const rules = [];
+        const rulesMap = {};
+        if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+            rules.push(defaultTo(props.default));
+        }
+        if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+            rules.push(objectOf(rulesMap));
+        }
+        else {
+            const parentRule = useParentRule();
+            rules.push(parentRule(objectOf(rulesMap)));
+        }
+        const rule = pipe(...rules);
+        if (props.ref) {
+            refRules[props.ref] = rule;
+        }
+        useRule(rule);
+        objectRuleContext.set(handler, rulesMap);
+        ruleContext.set(handler, null);
+        parentRuleContext.reset(handler);
+        innet(children, handler);
+    }
+    else if (props.ref) {
+        useRule(refRules[props.ref]);
+    }
+};
+
+export { object };

package/plugins/schema/object/object.js

@@ -0,0 +1,62 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var innet = require('innet');
+var jsx = require('@innet/jsx');
+require('../../../hooks/index.js');
+require('../../../hooks/useParentRule/index.js');
+require('../../../utils/index.js');
+var useBlock = require('../../../hooks/useBlock/useBlock.js');
+var useApi = require('../../../hooks/useApi/useApi.js');
+var useSchemaType = require('../../../hooks/useSchemaType/useSchemaType.js');
+var useSchemaContext = require('../../../hooks/useSchemaContext/useSchemaContext.js');
+var useParentRule = require('../../../hooks/useParentRule/useParentRule.js');
+var defaultTo = require('../../../utils/rules/defaultTo/defaultTo.js');
+var objectOf = require('../../../utils/rules/objectOf/objectOf.js');
+var pipe = require('../../../utils/rules/pipe/pipe.js');
+var useRule = require('../../../hooks/useRule/useRule.js');
+var useObjectRule = require('../../../hooks/useObjectRule/useObjectRule.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var innet__default = /*#__PURE__*/_interopDefaultLegacy(innet);
+
+const object = () => {
+    useBlock.useBlock('path');
+    const children = jsx.useChildren();
+    const props = jsx.useProps() || {};
+    const { refRules } = useApi.useApi();
+    const schema = useSchemaType.useSchemaType('object', props);
+    const handler = innet.useNewHandler();
+    if (schema) {
+        useSchemaContext.schemaContext.set(handler, schema);
+        useParentRule.parentRuleContext.reset(handler);
+        const rules = [];
+        const rulesMap = {};
+        if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+            rules.push(defaultTo.defaultTo(props.default));
+        }
+        if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+            rules.push(objectOf.objectOf(rulesMap));
+        }
+        else {
+            const parentRule = useParentRule.useParentRule();
+            rules.push(parentRule(objectOf.objectOf(rulesMap)));
+        }
+        const rule = pipe.pipe(...rules);
+        if (props.ref) {
+            refRules[props.ref] = rule;
+        }
+        useRule.useRule(rule);
+        useObjectRule.objectRuleContext.set(handler, rulesMap);
+        useRule.ruleContext.set(handler, null);
+        useParentRule.parentRuleContext.reset(handler);
+        innet__default["default"](children, handler);
+    }
+    else if (props.ref) {
+        useRule.useRule(refRules[props.ref]);
+    }
+};
+
+exports.object = object;

package/plugins/schema/string/index.d.ts

@@ -0,0 +1 @@
+export * from './string';

package/plugins/schema/string/index.es6.js

@@ -0,0 +1 @@
+export { string } from './string.es6.js';

package/plugins/schema/string/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var string = require('./string.js');
+
+
+
+exports.string = string.string;

package/plugins/schema/string/string.d.ts

@@ -0,0 +1,9 @@
+import { type HandlerPlugin } from 'innet';
+import { type ValuesSchemaProps } from '../../../types';
+export interface StringProps extends ValuesSchemaProps<string> {
+    min?: number;
+    max?: number;
+    pattern?: string | RegExp;
+    patternId?: string;
+}
+export declare const string: HandlerPlugin;

package/plugins/schema/string/string.es6.js

@@ -0,0 +1,51 @@
+import { __rest } from 'tslib';
+import { useProps } from '@innet/jsx';
+import '../../../hooks/index.es6.js';
+import '../../../hooks/useParentRule/index.es6.js';
+import '../../../utils/index.es6.js';
+import { useSchemaType } from '../../../hooks/useSchemaType/useSchemaType.es6.js';
+import { defaultTo } from '../../../utils/rules/defaultTo/defaultTo.es6.js';
+import { values } from '../../../utils/rules/values/values.es6.js';
+import { minLength } from '../../../utils/rules/minLength/minLength.es6.js';
+import { maxLength } from '../../../utils/rules/maxLength/maxLength.es6.js';
+import { pattern } from '../../../utils/rules/pattern/pattern.es6.js';
+import { useRule } from '../../../hooks/useRule/useRule.es6.js';
+import { pipe } from '../../../utils/rules/pipe/pipe.es6.js';
+import { useParentRule } from '../../../hooks/useParentRule/useParentRule.es6.js';
+
+const string = () => {
+    const _a = useProps() || {}, { min, max, pattern: pattern$1, patternId } = _a, props = __rest(_a, ["min", "max", "pattern", "patternId"]);
+    const schema = useSchemaType('string', props);
+    const rules = [];
+    if (props.default !== undefined) {
+        rules.push(defaultTo(props.default));
+    }
+    rules.push(String);
+    if (props.values) {
+        rules.push(values(props.values));
+    }
+    if (min !== undefined) {
+        // @ts-expect-error: FIXME
+        schema.minimum = min;
+        rules.push(minLength(min));
+    }
+    if (max !== undefined) {
+        // @ts-expect-error: FIXME
+        schema.maximum = max;
+        rules.push(maxLength(max));
+    }
+    if (pattern$1 !== undefined) {
+        // @ts-expect-error: FIXME
+        schema.pattern = String(pattern$1);
+        rules.push(pattern(pattern$1, patternId));
+    }
+    if (props.default) {
+        useRule(pipe(...rules));
+    }
+    else {
+        const parentRule = useParentRule();
+        useRule(parentRule(pipe(...rules)));
+    }
+};
+
+export { string };

package/plugins/schema/string/string.js

@@ -0,0 +1,55 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var jsx = require('@innet/jsx');
+require('../../../hooks/index.js');
+require('../../../hooks/useParentRule/index.js');
+require('../../../utils/index.js');
+var useSchemaType = require('../../../hooks/useSchemaType/useSchemaType.js');
+var defaultTo = require('../../../utils/rules/defaultTo/defaultTo.js');
+var values = require('../../../utils/rules/values/values.js');
+var minLength = require('../../../utils/rules/minLength/minLength.js');
+var maxLength = require('../../../utils/rules/maxLength/maxLength.js');
+var pattern = require('../../../utils/rules/pattern/pattern.js');
+var useRule = require('../../../hooks/useRule/useRule.js');
+var pipe = require('../../../utils/rules/pipe/pipe.js');
+var useParentRule = require('../../../hooks/useParentRule/useParentRule.js');
+
+const string = () => {
+    const _a = jsx.useProps() || {}, { min, max, pattern: pattern$1, patternId } = _a, props = tslib.__rest(_a, ["min", "max", "pattern", "patternId"]);
+    const schema = useSchemaType.useSchemaType('string', props);
+    const rules = [];
+    if (props.default !== undefined) {
+        rules.push(defaultTo.defaultTo(props.default));
+    }
+    rules.push(String);
+    if (props.values) {
+        rules.push(values.values(props.values));
+    }
+    if (min !== undefined) {
+        // @ts-expect-error: FIXME
+        schema.minimum = min;
+        rules.push(minLength.minLength(min));
+    }
+    if (max !== undefined) {
+        // @ts-expect-error: FIXME
+        schema.maximum = max;
+        rules.push(maxLength.maxLength(max));
+    }
+    if (pattern$1 !== undefined) {
+        // @ts-expect-error: FIXME
+        schema.pattern = String(pattern$1);
+        rules.push(pattern.pattern(pattern$1, patternId));
+    }
+    if (props.default) {
+        useRule.useRule(pipe.pipe(...rules));
+    }
+    else {
+        const parentRule = useParentRule.useParentRule();
+        useRule.useRule(parentRule(pipe.pipe(...rules)));
+    }
+};
+
+exports.string = string;

package/plugins/schema/tuple/index.d.ts

@@ -0,0 +1 @@
+export * from './tuple';

package/plugins/schema/tuple/index.es6.js

@@ -0,0 +1 @@
+export { tuple } from './tuple.es6.js';

package/plugins/schema/tuple/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tuple = require('./tuple.js');
+
+
+
+exports.tuple = tuple.tuple;

package/plugins/schema/tuple/tuple.d.ts

@@ -0,0 +1,5 @@
+import { type HandlerPlugin } from 'innet';
+import { type BaseSchemaProps } from '../../../types';
+export interface TupleProps extends BaseSchemaProps<any[]> {
+}
+export declare const tuple: HandlerPlugin;

package/plugins/schema/tuple/tuple.es6.js

@@ -0,0 +1,54 @@
+import innet, { useNewHandler } from 'innet';
+import { useProps, useChildren } from '@innet/jsx';
+import { callHandler } from '@innet/utils';
+import '../../../hooks/index.es6.js';
+import '../../../hooks/useParentRule/index.es6.js';
+import '../../../utils/index.es6.js';
+import { useBlock } from '../../../hooks/useBlock/useBlock.es6.js';
+import { useSchemaType } from '../../../hooks/useSchemaType/useSchemaType.es6.js';
+import { schemaContext } from '../../../hooks/useSchemaContext/useSchemaContext.es6.js';
+import { defaultTo } from '../../../utils/rules/defaultTo/defaultTo.es6.js';
+import { tupleOf } from '../../../utils/rules/tupleOf/tupleOf.es6.js';
+import { useParentRule, parentRuleContext } from '../../../hooks/useParentRule/useParentRule.es6.js';
+import { useRule, ruleContext } from '../../../hooks/useRule/useRule.es6.js';
+import { pipe } from '../../../utils/rules/pipe/pipe.es6.js';
+import { required } from '../../../utils/rules/required/required.es6.js';
+
+const tuple = () => {
+    useBlock('path');
+    const handler = useNewHandler();
+    const props = useProps();
+    const schema = useSchemaType('array', props);
+    const children = useChildren();
+    if (schema) {
+        const schemas = [];
+        handler[schemaContext.key] = schemas;
+        // @ts-expect-error: FIXME
+        schema.prefixItems = schemas;
+        const rulesMap = [];
+        const rules = [];
+        if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+            rules.push(defaultTo(props.default));
+        }
+        if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+            rules.push(tupleOf(rulesMap));
+        }
+        else {
+            const parentRule = useParentRule();
+            rules.push(parentRule(tupleOf(rulesMap)));
+        }
+        useRule(pipe(...rules));
+        parentRuleContext.set(handler, rule => required(rule));
+        ruleContext.set(handler, rule => {
+            rulesMap.push(rule);
+        });
+        innet(children, handler);
+        innet(() => {
+            if (!rulesMap.length) {
+                throw Error('<tuple> MUST have content');
+            }
+        }, callHandler);
+    }
+};
+
+export { tuple };

package/plugins/schema/tuple/tuple.js

@@ -0,0 +1,62 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var innet = require('innet');
+var jsx = require('@innet/jsx');
+var utils = require('@innet/utils');
+require('../../../hooks/index.js');
+require('../../../hooks/useParentRule/index.js');
+require('../../../utils/index.js');
+var useBlock = require('../../../hooks/useBlock/useBlock.js');
+var useSchemaType = require('../../../hooks/useSchemaType/useSchemaType.js');
+var useSchemaContext = require('../../../hooks/useSchemaContext/useSchemaContext.js');
+var defaultTo = require('../../../utils/rules/defaultTo/defaultTo.js');
+var tupleOf = require('../../../utils/rules/tupleOf/tupleOf.js');
+var useParentRule = require('../../../hooks/useParentRule/useParentRule.js');
+var useRule = require('../../../hooks/useRule/useRule.js');
+var pipe = require('../../../utils/rules/pipe/pipe.js');
+var required = require('../../../utils/rules/required/required.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var innet__default = /*#__PURE__*/_interopDefaultLegacy(innet);
+
+const tuple = () => {
+    useBlock.useBlock('path');
+    const handler = innet.useNewHandler();
+    const props = jsx.useProps();
+    const schema = useSchemaType.useSchemaType('array', props);
+    const children = jsx.useChildren();
+    if (schema) {
+        const schemas = [];
+        handler[useSchemaContext.schemaContext.key] = schemas;
+        // @ts-expect-error: FIXME
+        schema.prefixItems = schemas;
+        const rulesMap = [];
+        const rules = [];
+        if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+            rules.push(defaultTo.defaultTo(props.default));
+        }
+        if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
+            rules.push(tupleOf.tupleOf(rulesMap));
+        }
+        else {
+            const parentRule = useParentRule.useParentRule();
+            rules.push(parentRule(tupleOf.tupleOf(rulesMap)));
+        }
+        useRule.useRule(pipe.pipe(...rules));
+        useParentRule.parentRuleContext.set(handler, rule => required.required(rule));
+        useRule.ruleContext.set(handler, rule => {
+            rulesMap.push(rule);
+        });
+        innet__default["default"](children, handler);
+        innet__default["default"](() => {
+            if (!rulesMap.length) {
+                throw Error('<tuple> MUST have content');
+            }
+        }, utils.callHandler);
+    }
+};
+
+exports.tuple = tuple;

package/plugins/schema/uuid/index.d.ts

@@ -0,0 +1 @@
+export * from './uuid';

package/plugins/schema/uuid/index.es6.js

@@ -0,0 +1 @@
+export { uuid } from './uuid.es6.js';

package/plugins/schema/uuid/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var uuid = require('./uuid.js');
+
+
+
+exports.uuid = uuid.uuid;

package/plugins/schema/uuid/uuid.d.ts

@@ -0,0 +1,6 @@
+import { type HandlerPlugin } from 'innet';
+import { type ValuesSchemaProps } from '../../../types';
+export interface UuidProps extends ValuesSchemaProps<string> {
+    default?: 'new' | string;
+}
+export declare const uuid: HandlerPlugin;

package/plugins/schema/uuid/uuid.es6.js

@@ -0,0 +1,39 @@
+import { __rest } from 'tslib';
+import { useProps } from '@innet/jsx';
+import { v4 } from 'uuid';
+import '../../../hooks/index.es6.js';
+import '../../../utils/index.es6.js';
+import { useSchemaType } from '../../../hooks/useSchemaType/useSchemaType.es6.js';
+import { defaultTo } from '../../../utils/rules/defaultTo/defaultTo.es6.js';
+import { uuidTo } from '../../../utils/rules/uuidTo/uuidTo.es6.js';
+import { values } from '../../../utils/rules/values/values.es6.js';
+import { useRule } from '../../../hooks/useRule/useRule.es6.js';
+import { optional } from '../../../utils/rules/optional/optional.es6.js';
+import { pipe } from '../../../utils/rules/pipe/pipe.es6.js';
+
+const uuid = () => {
+    const _a = useProps() || {}, { default: defaultValue } = _a, props = __rest(_a, ["default"]);
+    const schema = useSchemaType('string', Object.assign(Object.assign({}, props), { default: defaultValue === 'new' ? undefined : defaultValue }));
+    // @ts-expect-error: FIXME
+    schema.format = 'uuid';
+    if (defaultValue === 'new') {
+        // @ts-expect-error: FIXME
+        schema['x-default'] = defaultValue;
+    }
+    const rules = [];
+    if (defaultValue !== undefined) {
+        rules.push(defaultTo(defaultValue === 'new' ? v4 : defaultValue));
+    }
+    rules.push(uuidTo);
+    if (props.values) {
+        rules.push(values(props.values));
+    }
+    if (defaultValue === undefined) {
+        useRule(optional(pipe(...rules)));
+    }
+    else {
+        useRule(pipe(...rules));
+    }
+};
+
+export { uuid };

package/plugins/schema/uuid/uuid.js

@@ -0,0 +1,43 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var jsx = require('@innet/jsx');
+var uuid$1 = require('uuid');
+require('../../../hooks/index.js');
+require('../../../utils/index.js');
+var useSchemaType = require('../../../hooks/useSchemaType/useSchemaType.js');
+var defaultTo = require('../../../utils/rules/defaultTo/defaultTo.js');
+var uuidTo = require('../../../utils/rules/uuidTo/uuidTo.js');
+var values = require('../../../utils/rules/values/values.js');
+var useRule = require('../../../hooks/useRule/useRule.js');
+var optional = require('../../../utils/rules/optional/optional.js');
+var pipe = require('../../../utils/rules/pipe/pipe.js');
+
+const uuid = () => {
+    const _a = jsx.useProps() || {}, { default: defaultValue } = _a, props = tslib.__rest(_a, ["default"]);
+    const schema = useSchemaType.useSchemaType('string', Object.assign(Object.assign({}, props), { default: defaultValue === 'new' ? undefined : defaultValue }));
+    // @ts-expect-error: FIXME
+    schema.format = 'uuid';
+    if (defaultValue === 'new') {
+        // @ts-expect-error: FIXME
+        schema['x-default'] = defaultValue;
+    }
+    const rules = [];
+    if (defaultValue !== undefined) {
+        rules.push(defaultTo.defaultTo(defaultValue === 'new' ? uuid$1.v4 : defaultValue));
+    }
+    rules.push(uuidTo.uuidTo);
+    if (props.values) {
+        rules.push(values.values(props.values));
+    }
+    if (defaultValue === undefined) {
+        useRule.useRule(optional.optional(pipe.pipe(...rules)));
+    }
+    else {
+        useRule.useRule(pipe.pipe(...rules));
+    }
+};
+
+exports.uuid = uuid;

package/plugins/utils/dev/dev.d.ts

@@ -0,0 +1,4 @@
+import { type HandlerPlugin } from 'innet';
+export interface DevProps {
+}
+export declare const dev: HandlerPlugin;

package/plugins/utils/dev/dev.es6.js

@@ -0,0 +1,10 @@
+import innet, { useHandler } from 'innet';
+import { useChildren } from '@innet/jsx';
+
+const dev = () => {
+    if (process.env.NODE_ENV === 'development') {
+        innet(useChildren(), useHandler());
+    }
+};
+
+export { dev };

package/plugins/utils/dev/dev.js

@@ -0,0 +1,18 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var innet = require('innet');
+var jsx = require('@innet/jsx');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var innet__default = /*#__PURE__*/_interopDefaultLegacy(innet);
+
+const dev = () => {
+    if (process.env.NODE_ENV === 'development') {
+        innet__default["default"](jsx.useChildren(), innet.useHandler());
+    }
+};
+
+exports.dev = dev;

package/plugins/utils/dev/index.d.ts

@@ -0,0 +1 @@
+export * from './dev';

package/plugins/utils/dev/index.es6.js

@@ -0,0 +1 @@
+export { dev } from './dev.es6.js';

package/plugins/utils/dev/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var dev = require('./dev.js');
+
+
+
+exports.dev = dev.dev;

package/plugins/utils/dts/dts.d.ts

@@ -0,0 +1,6 @@
+import { type HandlerPlugin } from 'innet';
+import { type Config } from 'dtsgenerator/dist/core/config';
+export interface DtsProps extends Partial<Config> {
+    path: string;
+}
+export declare const dts: HandlerPlugin;

package/plugins/utils/dts/dts.es6.js

@@ -0,0 +1,35 @@
+import { __rest, __awaiter } from 'tslib';
+import { useProps } from '@innet/jsx';
+import dtsGenerator, { parseSchema } from 'dtsgenerator';
+import fs from 'node:fs';
+import '../../../hooks/index.es6.js';
+import { useApi } from '../../../hooks/useApi/useApi.es6.js';
+
+const dts = () => {
+    const _a = useProps(), { path } = _a, config = __rest(_a, ["path"]);
+    const { docs } = useApi();
+    dtsGenerator({
+        contents: [parseSchema(JSON.parse(JSON.stringify(docs)))],
+        config,
+    }).then((content) => __awaiter(void 0, void 0, void 0, function* () {
+        yield fs.promises.writeFile(path, `interface Bin {
+  filename: string
+  fieldName: string
+  originalFilename: string
+  path: string
+  type: string
+  disposition: string
+  size: number
+  extension?: string
+}
+${content
+            .replaceAll(';', '')
+            .replaceAll('number // int64', 'bigint')
+            .replaceAll('string // binary', 'Bin')
+            .replaceAll('string // date-time', 'Date')}`);
+    })).catch(error => {
+        console.warn(error);
+    });
+};
+
+export { dts };

package/plugins/utils/dts/dts.js

@@ -0,0 +1,44 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var tslib = require('tslib');
+var jsx = require('@innet/jsx');
+var dtsGenerator = require('dtsgenerator');
+var fs = require('node:fs');
+require('../../../hooks/index.js');
+var useApi = require('../../../hooks/useApi/useApi.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var dtsGenerator__default = /*#__PURE__*/_interopDefaultLegacy(dtsGenerator);
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+
+const dts = () => {
+    const _a = jsx.useProps(), { path } = _a, config = tslib.__rest(_a, ["path"]);
+    const { docs } = useApi.useApi();
+    dtsGenerator__default["default"]({
+        contents: [dtsGenerator.parseSchema(JSON.parse(JSON.stringify(docs)))],
+        config,
+    }).then((content) => tslib.__awaiter(void 0, void 0, void 0, function* () {
+        yield fs__default["default"].promises.writeFile(path, `interface Bin {
+  filename: string
+  fieldName: string
+  originalFilename: string
+  path: string
+  type: string
+  disposition: string
+  size: number
+  extension?: string
+}
+${content
+            .replaceAll(';', '')
+            .replaceAll('number // int64', 'bigint')
+            .replaceAll('string // binary', 'Bin')
+            .replaceAll('string // date-time', 'Date')}`);
+    })).catch(error => {
+        console.warn(error);
+    });
+};
+
+exports.dts = dts;

package/plugins/utils/dts/index.d.ts

@@ -0,0 +1 @@
+export * from './dts';