@innet/server 2.0.0-alpha.9 → 2.0.0-beta.10

package/plugins/schema/integer/integer.d.ts

@@ -1,8 +1,45 @@
 import { type HandlerPlugin } from 'innet';
 import { type IntegerFormats, type ValuesSchemaProps } from '../../../types';
-export interface IntegerProps extends ValuesSchemaProps<number | bigint> {
+export interface IntegerProps extends ValuesSchemaProps<bigint | number> {
+    /**
+     * The `exclusiveMaximum` keyword is used to restrict the value to be less than the specified number.
+     * @example For example, the following value is valid:
+     * ```tsx
+     * <integer exclusiveMaximum={10} />
+     * ```
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers
+     * */
+    exclusiveMaximum?: bigint | boolean | number;
+    /**
+     * The `exclusiveMinimum` keyword is used to restrict the value to be greater than the specified number.
+     * @example For example, the following value is valid:
+     * ```tsx
+     * <integer exclusiveMinimum={10} />
+     * ```
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers
+     * */
+    exclusiveMinimum?: bigint | boolean | number;
+    /**
+     * An optional format modifier serves as a hint at the contents and format of the string.
+     * @example For example, the following value is valid:
+     * ```tsx
+     * <integer format='int64' />
+     * ```
+     * @see https://swagger.io/docs/specification/data-models/data-types/#numbers
+     * */
     format?: IntegerFormats;
-    min?: number | bigint;
-    max?: number | bigint;
+    /** Validate the integer number value by maximum. */
+    max?: bigint | number;
+    /** Validate the integer number value by minimum. */
+    min?: bigint | number;
+    /**
+     * The `multipleOf` keyword is used to restrict the value to be a multiple of the specified number.
+     * @example For example, the following value is valid:
+     * ```tsx
+     * <number multipleOf={2} />
+     * ```
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers
+     * */
+    multipleOf?: bigint | number;
 }
 export declare const integer: HandlerPlugin;

package/plugins/schema/integer/integer.es6.js

@@ -1,4 +1,3 @@
-import { __rest } from 'tslib';
 import { useProps } from '@innet/jsx';
 import '../../../hooks/index.es6.js';
 import '../../../utils/index.es6.js';
@@ -13,14 +12,35 @@ import { optional } from '../../../utils/rules/optional/optional.es6.js';
 import { pipe } from '../../../utils/rules/pipe/pipe.es6.js';
 
 const integer = () => {
-    const _a = useProps() || {}, { format = 'int32', min: min$1, max: max$1, values: values$1, example, examples, default: defaultValue } = _a, props = __rest(_a, ["format", "min", "max", "values", "example", "examples", "default"]);
-    const schema = useSchemaType('integer', Object.assign(Object.assign({}, props), { default: defaultValue !== undefined ? Number(defaultValue) : undefined, example: example !== undefined ? Number(example) : undefined, examples: examples === null || examples === void 0 ? void 0 : examples.map(Number), values: values$1 === null || values$1 === void 0 ? void 0 : values$1.map(Number) }));
-    // @ts-expect-error: FIXME
-    schema.format = format;
-    // @ts-expect-error: FIXME
-    schema.minimum = min$1 !== undefined ? Number(min$1) : undefined;
-    // @ts-expect-error: FIXME
-    schema.maximum = max$1 !== undefined ? Number(max$1) : undefined;
+    const { default: defaultValue, example, examples, exclusiveMaximum, exclusiveMinimum, format = 'int32', max: max$1, min: min$1, multipleOf, values: values$1, ...props } = useProps() || {};
+    const schema = useSchemaType('integer', {
+        ...props,
+        const: props.const !== undefined ? Number(props.const) : undefined,
+        default: defaultValue !== undefined ? Number(defaultValue) : undefined,
+        example: example !== undefined ? Number(example) : undefined,
+        examples: examples === null || examples === void 0 ? void 0 : examples.map(Number),
+        values: values$1 === null || values$1 === void 0 ? void 0 : values$1.map(Number),
+    });
+    if (schema) {
+        if (format) {
+            schema.format = format;
+        }
+        if (min$1 !== undefined) {
+            schema.minimum = Number(min$1);
+        }
+        if (max$1 !== undefined) {
+            schema.maximum = Number(max$1);
+        }
+        if (exclusiveMinimum) {
+            schema.exclusiveMinimum = typeof exclusiveMinimum === 'boolean' ? exclusiveMinimum : Number(exclusiveMinimum);
+        }
+        if (exclusiveMaximum) {
+            schema.exclusiveMaximum = typeof exclusiveMaximum === 'boolean' ? exclusiveMaximum : Number(exclusiveMaximum);
+        }
+        if (multipleOf !== undefined) {
+            schema.multipleOf = Number(multipleOf);
+        }
+    }
     const rules = [];
     if (defaultValue !== undefined) {
         rules.push(defaultTo(defaultValue));

package/plugins/schema/integer/integer.js

@@ -2,7 +2,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var tslib = require('tslib');
 var jsx = require('@innet/jsx');
 require('../../../hooks/index.js');
 require('../../../utils/index.js');
@@ -17,14 +16,35 @@ var optional = require('../../../utils/rules/optional/optional.js');
 var pipe = require('../../../utils/rules/pipe/pipe.js');
 
 const integer = () => {
-    const _a = jsx.useProps() || {}, { format = 'int32', min: min$1, max: max$1, values: values$1, example, examples, default: defaultValue } = _a, props = tslib.__rest(_a, ["format", "min", "max", "values", "example", "examples", "default"]);
-    const schema = useSchemaType.useSchemaType('integer', Object.assign(Object.assign({}, props), { default: defaultValue !== undefined ? Number(defaultValue) : undefined, example: example !== undefined ? Number(example) : undefined, examples: examples === null || examples === void 0 ? void 0 : examples.map(Number), values: values$1 === null || values$1 === void 0 ? void 0 : values$1.map(Number) }));
-    // @ts-expect-error: FIXME
-    schema.format = format;
-    // @ts-expect-error: FIXME
-    schema.minimum = min$1 !== undefined ? Number(min$1) : undefined;
-    // @ts-expect-error: FIXME
-    schema.maximum = max$1 !== undefined ? Number(max$1) : undefined;
+    const { default: defaultValue, example, examples, exclusiveMaximum, exclusiveMinimum, format = 'int32', max: max$1, min: min$1, multipleOf, values: values$1, ...props } = jsx.useProps() || {};
+    const schema = useSchemaType.useSchemaType('integer', {
+        ...props,
+        const: props.const !== undefined ? Number(props.const) : undefined,
+        default: defaultValue !== undefined ? Number(defaultValue) : undefined,
+        example: example !== undefined ? Number(example) : undefined,
+        examples: examples === null || examples === void 0 ? void 0 : examples.map(Number),
+        values: values$1 === null || values$1 === void 0 ? void 0 : values$1.map(Number),
+    });
+    if (schema) {
+        if (format) {
+            schema.format = format;
+        }
+        if (min$1 !== undefined) {
+            schema.minimum = Number(min$1);
+        }
+        if (max$1 !== undefined) {
+            schema.maximum = Number(max$1);
+        }
+        if (exclusiveMinimum) {
+            schema.exclusiveMinimum = typeof exclusiveMinimum === 'boolean' ? exclusiveMinimum : Number(exclusiveMinimum);
+        }
+        if (exclusiveMaximum) {
+            schema.exclusiveMaximum = typeof exclusiveMaximum === 'boolean' ? exclusiveMaximum : Number(exclusiveMaximum);
+        }
+        if (multipleOf !== undefined) {
+            schema.multipleOf = Number(multipleOf);
+        }
+    }
     const rules = [];
     if (defaultValue !== undefined) {
         rules.push(defaultTo.defaultTo(defaultValue));

package/plugins/schema/number/number.d.ts

@@ -1,9 +1,41 @@
 import { type HandlerPlugin } from 'innet';
 import { type ValuesSchemaProps } from '../../../types';
 export interface NumberProps extends ValuesSchemaProps<number> {
-    /** Validate the number value by minimum. */
-    min?: number;
+    /**
+     * The `exclusiveMaximum` keyword is used to restrict the value to be less than the specified number.
+     * @example For example, the following value is valid:
+     * ```tsx
+     * <number exclusiveMaximum={10} />
+     * ```
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers
+     * */
+    exclusiveMaximum?: boolean;
+    /**
+     * The `exclusiveMinimum` keyword is used to restrict the value to be greater than the specified number.
+     * @example For example, the following value is valid:
+     * ```tsx
+     * <number exclusiveMinimum={10} />
+     * ```
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers
+     * */
+    exclusiveMinimum?: boolean;
+    /**
+     * An optional format modifier serves as a hint at the contents and format of the string.
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers
+     * */
+    format?: 'double' | 'float' | (string & {});
     /** Validate the number value by maximum. */
     max?: number;
+    /** Validate the number value by minimum. */
+    min?: number;
+    /**
+     * The `multipleOf` keyword is used to restrict the value to be a multiple of the specified number.
+     * @example For example, the following value is valid:
+     * ```tsx
+     * <number multipleOf={2} />
+     * ```
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#numbers
+     * */
+    multipleOf?: number;
 }
 export declare const number: HandlerPlugin;

package/plugins/schema/number/number.es6.js

@@ -1,4 +1,3 @@
-import { __rest } from 'tslib';
 import { useProps } from '@innet/jsx';
 import '../../../hooks/index.es6.js';
 import '../../../hooks/useParentRule/index.es6.js';
@@ -14,12 +13,28 @@ import { useRule } from '../../../hooks/useRule/useRule.es6.js';
 import { pipe } from '../../../utils/rules/pipe/pipe.es6.js';
 
 const number = () => {
-    const _a = useProps() || {}, { min: min$1, max: max$1 } = _a, props = __rest(_a, ["min", "max"]);
+    const { exclusiveMaximum, exclusiveMinimum, format, max: max$1, min: min$1, multipleOf, ...props } = useProps() || {};
     const schema = useSchemaType('number', props);
-    // @ts-expect-error: FIXME
-    schema.minimum = min$1;
-    // @ts-expect-error: FIXME
-    schema.maximum = max$1;
+    if (schema) {
+        if (format !== undefined) {
+            schema.format = format;
+        }
+        if (min$1 !== undefined) {
+            schema.minimum = min$1;
+        }
+        if (max$1 !== undefined) {
+            schema.maximum = max$1;
+        }
+        if (exclusiveMinimum) {
+            schema.exclusiveMinimum = typeof exclusiveMinimum === 'boolean' ? exclusiveMinimum : Number(exclusiveMinimum);
+        }
+        if (exclusiveMaximum) {
+            schema.exclusiveMaximum = typeof exclusiveMaximum === 'boolean' ? exclusiveMaximum : Number(exclusiveMaximum);
+        }
+        if (multipleOf !== undefined) {
+            schema.multipleOf = Number(multipleOf);
+        }
+    }
     const rules = [];
     if (props.default !== undefined) {
         rules.push(defaultTo(props.default));

package/plugins/schema/number/number.js

@@ -2,7 +2,6 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var tslib = require('tslib');
 var jsx = require('@innet/jsx');
 require('../../../hooks/index.js');
 require('../../../hooks/useParentRule/index.js');
@@ -18,12 +17,28 @@ var useRule = require('../../../hooks/useRule/useRule.js');
 var pipe = require('../../../utils/rules/pipe/pipe.js');
 
 const number = () => {
-    const _a = jsx.useProps() || {}, { min: min$1, max: max$1 } = _a, props = tslib.__rest(_a, ["min", "max"]);
+    const { exclusiveMaximum, exclusiveMinimum, format, max: max$1, min: min$1, multipleOf, ...props } = jsx.useProps() || {};
     const schema = useSchemaType.useSchemaType('number', props);
-    // @ts-expect-error: FIXME
-    schema.minimum = min$1;
-    // @ts-expect-error: FIXME
-    schema.maximum = max$1;
+    if (schema) {
+        if (format !== undefined) {
+            schema.format = format;
+        }
+        if (min$1 !== undefined) {
+            schema.minimum = min$1;
+        }
+        if (max$1 !== undefined) {
+            schema.maximum = max$1;
+        }
+        if (exclusiveMinimum) {
+            schema.exclusiveMinimum = typeof exclusiveMinimum === 'boolean' ? exclusiveMinimum : Number(exclusiveMinimum);
+        }
+        if (exclusiveMaximum) {
+            schema.exclusiveMaximum = typeof exclusiveMaximum === 'boolean' ? exclusiveMaximum : Number(exclusiveMaximum);
+        }
+        if (multipleOf !== undefined) {
+            schema.multipleOf = Number(multipleOf);
+        }
+    }
     const rules = [];
     if (props.default !== undefined) {
         rules.push(defaultTo.defaultTo(props.default));

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

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

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

@@ -1,11 +1,12 @@
-import innet, { useNewHandler } from 'innet';
-import { useChildren, useProps } from '@innet/jsx';
+import { useNewHandler, innet } from 'innet';
+import { 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 { objectSchemaContext } from '../../../hooks/useObjectSchemaContext/useObjectSchemaContext.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';
@@ -13,28 +14,33 @@ 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';
+import { useEffect } from '../../../hooks/useEffect/useEffect.es6.js';
+import { getSafeSchema } from '../../../utils/getSafeSchema/getSafeSchema.es6.js';
 
 const object = () => {
     useBlock('path');
-    const children = useChildren();
-    const props = useProps() || {};
+    const { children, ...props } = useProps();
     const { refRules } = useApi();
     const schema = useSchemaType('object', props);
     const handler = useNewHandler();
     if (schema) {
-        schemaContext.set(handler, schema);
+        schema.additionalProperties = {};
+        objectSchemaContext.set(handler, schema);
+        schemaContext.set(handler, schema.additionalProperties);
         parentRuleContext.reset(handler);
         const rules = [];
         const rulesMap = {};
         if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
             rules.push(defaultTo(props.default));
         }
+        let childRule = v => v;
+        const restRule = (value, data) => childRule(value, data);
         if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
-            rules.push(objectOf(rulesMap));
+            rules.push(objectOf(rulesMap, restRule));
         }
         else {
             const parentRule = useParentRule();
-            rules.push(parentRule(objectOf(rulesMap)));
+            rules.push(parentRule(objectOf(rulesMap, restRule)));
         }
         const rule = pipe(...rules);
         if (props.ref) {
@@ -42,9 +48,17 @@ const object = () => {
         }
         useRule(rule);
         objectRuleContext.set(handler, rulesMap);
-        ruleContext.set(handler, null);
+        ruleContext.set(handler, rule => {
+            childRule = rule;
+        });
         parentRuleContext.reset(handler);
         innet(children, handler);
+        useEffect(() => {
+            const safeSchema = getSafeSchema(schema);
+            if (!Object.keys(safeSchema.additionalProperties).length) {
+                delete safeSchema.additionalProperties;
+            }
+        });
     }
     else if (props.ref) {
         useRule(refRules[props.ref]);

package/plugins/schema/object/object.js

@@ -10,6 +10,7 @@ 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 useObjectSchemaContext = require('../../../hooks/useObjectSchemaContext/useObjectSchemaContext.js');
 var useSchemaContext = require('../../../hooks/useSchemaContext/useSchemaContext.js');
 var useParentRule = require('../../../hooks/useParentRule/useParentRule.js');
 var defaultTo = require('../../../utils/rules/defaultTo/defaultTo.js');
@@ -17,32 +18,33 @@ 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);
+var useEffect = require('../../../hooks/useEffect/useEffect.js');
+var getSafeSchema = require('../../../utils/getSafeSchema/getSafeSchema.js');
 
 const object = () => {
     useBlock.useBlock('path');
-    const children = jsx.useChildren();
-    const props = jsx.useProps() || {};
+    const { children, ...props } = jsx.useProps();
     const { refRules } = useApi.useApi();
     const schema = useSchemaType.useSchemaType('object', props);
     const handler = innet.useNewHandler();
     if (schema) {
-        useSchemaContext.schemaContext.set(handler, schema);
+        schema.additionalProperties = {};
+        useObjectSchemaContext.objectSchemaContext.set(handler, schema);
+        useSchemaContext.schemaContext.set(handler, schema.additionalProperties);
         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));
         }
+        let childRule = v => v;
+        const restRule = (value, data) => childRule(value, data);
         if ((props === null || props === void 0 ? void 0 : props.default) !== undefined) {
-            rules.push(objectOf.objectOf(rulesMap));
+            rules.push(objectOf.objectOf(rulesMap, restRule));
         }
         else {
             const parentRule = useParentRule.useParentRule();
-            rules.push(parentRule(objectOf.objectOf(rulesMap)));
+            rules.push(parentRule(objectOf.objectOf(rulesMap, restRule)));
         }
         const rule = pipe.pipe(...rules);
         if (props.ref) {
@@ -50,9 +52,17 @@ const object = () => {
         }
         useRule.useRule(rule);
         useObjectRule.objectRuleContext.set(handler, rulesMap);
-        useRule.ruleContext.set(handler, null);
+        useRule.ruleContext.set(handler, rule => {
+            childRule = rule;
+        });
         useParentRule.parentRuleContext.reset(handler);
-        innet__default["default"](children, handler);
+        innet.innet(children, handler);
+        useEffect.useEffect(() => {
+            const safeSchema = getSafeSchema.getSafeSchema(schema);
+            if (!Object.keys(safeSchema.additionalProperties).length) {
+                delete safeSchema.additionalProperties;
+            }
+        });
     }
     else if (props.ref) {
         useRule.useRule(refRules[props.ref]);

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

@@ -1,9 +1,36 @@
 import { type HandlerPlugin } from 'innet';
 import { type ValuesSchemaProps } from '../../../types';
 export interface StringProps extends ValuesSchemaProps<string> {
-    min?: number;
+    /**
+     * An optional format modifier serves as a hint at the contents and format of the string.
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#strings
+     * */
+    format?: 'binary' | 'byte' | 'date' | 'date-time' | 'email' | 'hostname' | 'ipv4' | 'ipv6' | 'password' | 'uri' | 'uuid' | (string & {});
+    /**
+     * String length can be restricted using `min` and `max`.
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#strings
+     * */
     max?: number;
-    pattern?: string | RegExp;
+    /**
+     * String length can be restricted using `min` and `max`.
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#strings
+     * */
+    min?: number;
+    /**
+     * The pattern keyword lets you define a regular expression template for the string value.
+     * Only the values that match this template will be accepted.
+     * The regular expression syntax used is from JavaScript (more specifically, ECMA 262).
+     * Regular expressions are case-sensitive, that is, [a-z] and [A-Z] are different expressions.
+     * @example For example, the following pattern matches a Social Security Number (SSN) in the 123-45-6789 format:
+     * ```tsx
+     * <string pattern='^\d{3}-\d{2}-\d{4}$' />
+     * ```
+     * @see https://swagger.io/docs/specification/v3_0/data-models/data-types/#strings
+     * */
+    pattern?: RegExp | string;
+    /**
+     * The `patternId` keyword is used to reference a pattern from the OpenAPI specification.
+     * */
     patternId?: string;
 }
 export declare const string: HandlerPlugin;

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

@@ -1,50 +1,69 @@
-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 { useApi } from '../../../hooks/useApi/useApi.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 { useRule } from '../../../hooks/useRule/useRule.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 { format, max, min, pattern: pattern$1, patternId, ...props } = useProps() || {};
+    const { refRules } = useApi();
     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));
+    if (schema) {
+        const rules = [];
+        if (format !== undefined) {
+            schema.format = format;
+        }
+        if (props.default !== undefined) {
+            rules.push(defaultTo(props.default));
+        }
+        rules.push(String);
+        if (props.values) {
+            rules.push(values(props.values));
+        }
+        if (format !== undefined) {
+            schema.format = format;
+        }
+        if (min !== undefined) {
+            schema.minLength = min;
+            rules.push(minLength(min));
+        }
+        if (max !== undefined) {
+            schema.maxLength = max;
+            rules.push(maxLength(max));
+        }
+        if (pattern$1 !== undefined) {
+            schema.pattern = String(pattern$1);
+            rules.push(pattern(pattern$1, patternId));
+        }
+        const rule = pipe(...rules);
+        if (props.ref) {
+            refRules[props.ref] = rule;
+        }
+        if (props.default !== undefined) {
+            useRule(rule);
+        }
+        else {
+            const parentRule = useParentRule();
+            useRule(parentRule(rule));
+        }
     }
-    else {
-        const parentRule = useParentRule();
-        useRule(parentRule(pipe(...rules)));
+    else if (props.ref) {
+        if (props.default !== undefined) {
+            useRule(refRules[props.ref]);
+        }
+        else {
+            const parentRule = useParentRule();
+            useRule(parentRule(refRules[props.ref]));
+        }
     }
 };