ts-fortress 4.3.1 → 4.4.0

package/dist/entry-point.mjs

@@ -34,6 +34,10 @@ export { safeUint } from './predefined/brand/number/safe-uint.mjs';
 export { uint } from './predefined/brand/number/uint.mjs';
 export { uint16 } from './predefined/brand/number/uint16.mjs';
 export { uint32 } from './predefined/brand/number/uint32.mjs';
+export { email } from './predefined/brand/string/email.mjs';
+export { iso8601 } from './predefined/brand/string/iso-8601.mjs';
+export { jsonString } from './predefined/brand/string/json-string.mjs';
+export { uuid, uuidV4, uuidV6, uuidV7 } from './predefined/brand/string/uuid.mjs';
 export { int8 } from './predefined/int8.mjs';
 export { JsonObject, JsonPrimitive, JsonValue } from './predefined/json.mjs';
 export { nullable } from './predefined/nullable.mjs';

package/dist/entry-point.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"entry-point.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"entry-point.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/globals.d.mts

@@ -1,5 +1,22 @@
- 
-
 /// <reference types="ts-type-forge" />
 
 type PartialReadonly<T> = Partial<Readonly<T>>;
+
+type Iso8601 = Brand<string, 'Iso8601'>;
+
+type Email = Brand<string, 'Email'>;
+
+type JsonString = Brand<string, 'JsonString'>;
+
+type UuidVersion = UintRangeInclusive<1, 8>;
+
+type UuidBaseString<V extends UuidVersion = UuidVersion> =
+  `${string}-${string}-${V}${string}-${string}-${string}`;
+
+type Uuid = Brand<UuidBaseString, 'Uuid'>;
+
+type Uuid4 = Brand<UuidBaseString<4>, 'Uuid'>;
+
+type Uuid6 = Brand<UuidBaseString<6>, 'Uuid'>;
+
+type Uuid7 = Brand<UuidBaseString<7>, 'Uuid'>;

package/dist/index.mjs

@@ -33,6 +33,10 @@ export { safeUint } from './predefined/brand/number/safe-uint.mjs';
 export { uint } from './predefined/brand/number/uint.mjs';
 export { uint16 } from './predefined/brand/number/uint16.mjs';
 export { uint32 } from './predefined/brand/number/uint32.mjs';
+export { email } from './predefined/brand/string/email.mjs';
+export { iso8601 } from './predefined/brand/string/iso-8601.mjs';
+export { jsonString } from './predefined/brand/string/json-string.mjs';
+export { uuid, uuidV4, uuidV6, uuidV7 } from './predefined/brand/string/uuid.mjs';
 export { int8 } from './predefined/int8.mjs';
 export { JsonObject, JsonPrimitive, JsonValue } from './predefined/json.mjs';
 export { nullable } from './predefined/nullable.mjs';

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/predefined/brand/index.d.mts

@@ -1,2 +1,3 @@
 export * from './number/index.mjs';
+export * from './string/index.mjs';
 //# sourceMappingURL=index.d.mts.map

package/dist/predefined/brand/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/predefined/brand/index.mts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../src/predefined/brand/index.mts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC"}

package/dist/predefined/brand/index.mjs

@@ -14,4 +14,8 @@ export { safeUint } from './number/safe-uint.mjs';
 export { uint } from './number/uint.mjs';
 export { uint16 } from './number/uint16.mjs';
 export { uint32 } from './number/uint32.mjs';
+export { email } from './string/email.mjs';
+export { iso8601 } from './string/iso-8601.mjs';
+export { jsonString } from './string/json-string.mjs';
+export { uuid, uuidV4, uuidV6, uuidV7 } from './string/uuid.mjs';
 //# sourceMappingURL=index.mjs.map

package/dist/predefined/brand/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}

package/dist/predefined/brand/string/email.d.mts

@@ -0,0 +1,6 @@
+import { type Type } from '../../../type.mjs';
+/**
+ * @link https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address
+ */
+export declare const email: (defaultValue?: string) => Type<Email>;
+//# sourceMappingURL=email.d.mts.map

package/dist/predefined/brand/string/email.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"email.d.mts","sourceRoot":"","sources":["../../../../src/predefined/brand/string/email.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,KAAK,GAAI,eAAe,MAAM,KAAG,IAAI,CAAC,KAAK,CAMpD,CAAC"}

package/dist/predefined/brand/string/email.mjs

@@ -0,0 +1,19 @@
+import 'ts-data-forge';
+import { brandedString } from '../../../brand/branded-string.mjs';
+
+/**
+ * @link https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address
+ */
+const email = (defaultValue) => brandedString({
+    is: (s) => regexpEmailAddress.test(s),
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    defaultValue: (defaultValue ?? defaultEmail),
+    typeName: 'Email',
+});
+const defaultEmail = 'ts-f.o.r.t.r.e.s.s@gmail.com';
+const regexpEmailAddress = 
+// eslint-disable-next-line security/detect-unsafe-regex
+/^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/gu;
+
+export { email };
+//# sourceMappingURL=email.mjs.map

package/dist/predefined/brand/string/email.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"email.mjs","sources":["../../../../src/predefined/brand/string/email.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAGA;;AAEG;AACI,MAAM,KAAK,GAAG,CAAC,YAAqB,KACzC,aAAa,CAAC;IACZ,EAAE,EAAE,CAAC,CAAC,KAAiB,kBAAkB,CAAC,IAAI,CAAC,CAAC,CAAC;;AAEjD,IAAA,YAAY,GAAG,YAAY,IAAI,YAAY,CAAU;AACrD,IAAA,QAAQ,EAAE,OAAO;AAClB,CAAA;AAEH,MAAM,YAAY,GAAG,8BAA8B;AAEnD,MAAM,kBAAkB;AACtB;AACA,wIAAwI;;;;"}

package/dist/predefined/brand/string/index.d.mts

@@ -0,0 +1,5 @@
+export * from './email.mjs';
+export * from './iso-8601.mjs';
+export * from './json-string.mjs';
+export * from './uuid.mjs';
+//# sourceMappingURL=index.d.mts.map

package/dist/predefined/brand/string/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","sourceRoot":"","sources":["../../../../src/predefined/brand/string/index.mts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,mBAAmB,CAAC;AAClC,cAAc,YAAY,CAAC"}

package/dist/predefined/brand/string/index.mjs

@@ -0,0 +1,5 @@
+export { email } from './email.mjs';
+export { iso8601 } from './iso-8601.mjs';
+export { jsonString } from './json-string.mjs';
+export { uuid, uuidV4, uuidV6, uuidV7 } from './uuid.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/predefined/brand/string/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;"}

package/dist/predefined/brand/string/iso-8601.d.mts

@@ -0,0 +1,69 @@
+import { type Type, type TypeOf } from '../../../type.mjs';
+/**
+ * @link https://github.com/validatorjs/validator.js/tree/v13.1.17?tab=readme-ov-file#validators
+ * @link https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString
+ * @link https://tc39.es/ecma262/multipage/numbers-and-dates.html#sec-date-time-string-format
+ */
+export declare const iso8601: (options?: ISO8601ValidatorOption) => Type<Iso8601>;
+declare const ISO8601ValidatorOption: import("../../../type.mjs").RecordType<{
+    /**
+     *  If strict is true, date strings with invalid dates like 2009-02-29 will be invalid.
+     */
+    readonly strict: Readonly<{
+        typeName: string;
+        defaultValue: boolean;
+        is: (a: unknown) => a is boolean;
+        assertIs: (a: unknown) => asserts a is boolean;
+        cast: (a: unknown) => boolean;
+        fill: (a: unknown) => boolean;
+        validate: (a: unknown) => import("ts-data-forge").Result<boolean, readonly Readonly<{
+            path: readonly string[];
+            actualValue: unknown;
+            expectedType: string;
+            typeName: string;
+            message: string | undefined;
+        }>[]>;
+        optional?: true;
+    }>;
+    /**
+     * If strictSeparator is true, date strings with date and time separated by anything other than a T will be invalid.
+     */
+    readonly strictSeparator: Readonly<{
+        typeName: string;
+        defaultValue: boolean;
+        is: (a: unknown) => a is boolean;
+        assertIs: (a: unknown) => asserts a is boolean;
+        cast: (a: unknown) => boolean;
+        fill: (a: unknown) => boolean;
+        validate: (a: unknown) => import("ts-data-forge").Result<boolean, readonly Readonly<{
+            path: readonly string[];
+            actualValue: unknown;
+            expectedType: string;
+            typeName: string;
+            message: string | undefined;
+        }>[]>;
+        optional?: true;
+    }>;
+    /**
+     * @default `new Date().toISOString()`
+     */
+    readonly defaultValue: Readonly<{
+        typeName: string;
+        defaultValue: string;
+        is: (a: unknown) => a is string;
+        assertIs: (a: unknown) => asserts a is string;
+        cast: (a: unknown) => string;
+        fill: (a: unknown) => string;
+        validate: (a: unknown) => import("ts-data-forge").Result<string, readonly Readonly<{
+            path: readonly string[];
+            actualValue: unknown;
+            expectedType: string;
+            typeName: string;
+            message: string | undefined;
+        }>[]>;
+        optional?: true;
+    }>;
+}>;
+type ISO8601ValidatorOption = TypeOf<typeof ISO8601ValidatorOption>;
+export {};
+//# sourceMappingURL=iso-8601.d.mts.map

package/dist/predefined/brand/string/iso-8601.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iso-8601.d.mts","sourceRoot":"","sources":["../../../../src/predefined/brand/string/iso-8601.mts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,IAAI,EAAE,KAAK,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAE3D;;;;GAIG;AACH,eAAO,MAAM,OAAO,GAAI,UAAU,sBAAsB,KAAG,IAAI,CAAC,OAAO,CAUtE,CAAC;AAEF,QAAA,MAAM,sBAAsB;IAC1B;;OAEG;;;;;;;;;;;;;;;;;IAGH;;OAEG;;;;;;;;;;;;;;;;;IAGH;;OAEG;;;;;;;;;;;;;;;;;EAEH,CAAC;AAEH,KAAK,sBAAsB,GAAG,MAAM,CAAC,OAAO,sBAAsB,CAAC,CAAC"}

package/dist/predefined/brand/string/iso-8601.mjs

@@ -0,0 +1,82 @@
+import 'ts-data-forge';
+import { boolean } from '../../../primitives/boolean.mjs';
+import { string } from '../../../primitives/string.mjs';
+import { brandedString } from '../../../brand/branded-string.mjs';
+import { record } from '../../../record/record.mjs';
+
+/**
+ * @link https://github.com/validatorjs/validator.js/tree/v13.1.17?tab=readme-ov-file#validators
+ * @link https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString
+ * @link https://tc39.es/ecma262/multipage/numbers-and-dates.html#sec-date-time-string-format
+ */
+const iso8601 = (options) => {
+    const filledOptions = ISO8601ValidatorOption.fill(options);
+    const is = isISO8601(filledOptions);
+    return brandedString({
+        is,
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        defaultValue: filledOptions.defaultValue,
+        typeName: 'Iso8601',
+    });
+};
+const ISO8601ValidatorOption = record({
+    /**
+     *  If strict is true, date strings with invalid dates like 2009-02-29 will be invalid.
+     */
+    strict: boolean(false),
+    /**
+     * If strictSeparator is true, date strings with date and time separated by anything other than a T will be invalid.
+     */
+    strictSeparator: boolean(false),
+    /**
+     * @default `new Date().toISOString()`
+     */
+    defaultValue: string(new Date().toISOString()),
+});
+const isISO8601 = (options) => (str) => {
+    const filledOptions = ISO8601ValidatorOption.fill(options);
+    const check = filledOptions.strictSeparator
+        ? regexpIso8601StrictSeparator.test(str)
+        : regexpIso8601.test(str);
+    if (check && filledOptions.strict)
+        return isValidDate(str);
+    return check;
+};
+// from http://goo.gl/0ejHHW
+const regexpIso8601 = 
+// eslint-disable-next-line security/detect-unsafe-regex
+/^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-3])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([\sT]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([,.]\d+(?!:))?)?(\17[0-5]\d([,.]\d+)?)?([Zz]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/u;
+// same as above, except with a strict 'T' separator between date and time
+const regexpIso8601StrictSeparator = 
+// eslint-disable-next-line security/detect-unsafe-regex
+/^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-3])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))(T((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([,.]\d+(?!:))?)?(\17[0-5]\d([,.]\d+)?)?([Zz]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/u;
+const isValidDate = (str) => {
+    // str must have passed the ISO8601 check
+    // this check is meant to catch invalid dates
+    // like 2009-02-31
+    // first check for ordinal dates
+    const ordinalMatch = /^(\d{4})-?(\d{3})([ T]\.*|$)/u.exec(str);
+    if (ordinalMatch !== null) {
+        const oYear = Number(ordinalMatch[1]);
+        const oDay = Number(ordinalMatch[2]);
+        // if is leap year
+        if ((oYear % 4 === 0 && oYear % 100 !== 0) || oYear % 400 === 0)
+            return oDay <= 366;
+        return oDay <= 365;
+    }
+    const match = /(\d{4})-?(\d{0,2})-?(\d*)/u.exec(str)?.map(Number);
+    const year = match?.[1];
+    const month = match?.[2];
+    const date = match?.[3];
+    // create a date object and compare
+    const d = new Date(`${year}-${`0${month ?? 1}`.slice(-2)}-${`0${date ?? 1}`.slice(-2)}`);
+    if (month !== undefined && date !== undefined) {
+        return (d.getUTCFullYear() === year &&
+            d.getUTCMonth() + 1 === month &&
+            d.getUTCDate() === date);
+    }
+    return true;
+};
+
+export { iso8601 };
+//# sourceMappingURL=iso-8601.mjs.map

package/dist/predefined/brand/string/iso-8601.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"iso-8601.mjs","sources":["../../../../src/predefined/brand/string/iso-8601.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;;;AAKA;;;;AAIG;AACI,MAAM,OAAO,GAAG,CAAC,OAAgC,KAAmB;IACzE,MAAM,aAAa,GAAG,sBAAsB,CAAC,IAAI,CAAC,OAAO,CAAC;AAC1D,IAAA,MAAM,EAAE,GAAG,SAAS,CAAC,aAAa,CAAC;AAEnC,IAAA,OAAO,aAAa,CAAC;QACnB,EAAE;;QAEF,YAAY,EAAE,aAAa,CAAC,YAAuB;AACnD,QAAA,QAAQ,EAAE,SAAS;AACpB,KAAA,CAAC;AACJ;AAEA,MAAM,sBAAsB,GAAG,MAAM,CAAC;AACpC;;AAEG;AACH,IAAA,MAAM,EAAE,OAAO,CAAC,KAAK,CAAC;AAEtB;;AAEG;AACH,IAAA,eAAe,EAAE,OAAO,CAAC,KAAK,CAAC;AAE/B;;AAEG;IACH,YAAY,EAAE,MAAM,CAAC,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;AAC/C,CAAA,CAAC;AAIF,MAAM,SAAS,GACb,CAAC,OAAqE,KACtE,CAAC,GAAW,KAAoB;IAC9B,MAAM,aAAa,GAAG,sBAAsB,CAAC,IAAI,CAAC,OAAO,CAAC;AAE1D,IAAA,MAAM,KAAK,GAAG,aAAa,CAAC;AAC1B,UAAE,4BAA4B,CAAC,IAAI,CAAC,GAAG;AACvC,UAAE,aAAa,CAAC,IAAI,CAAC,GAAG,CAAC;AAE3B,IAAA,IAAI,KAAK,IAAI,aAAa,CAAC,MAAM;AAAE,QAAA,OAAO,WAAW,CAAC,GAAG,CAAC;AAC1D,IAAA,OAAO,KAAK;AACd,CAAC;AAEH;AACA,MAAM,aAAa;AACjB;AACA,yRAAyR;AAE3R;AACA,MAAM,4BAA4B;AAChC;AACA,qRAAqR;AAEvR,MAAM,WAAW,GAAG,CAAC,GAAW,KAAa;;;;;IAK3C,MAAM,YAAY,GAAG,+BAA+B,CAAC,IAAI,CAAC,GAAG,CAAC;AAC9D,IAAA,IAAI,YAAY,KAAK,IAAI,EAAE;QACzB,MAAM,KAAK,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;QACrC,MAAM,IAAI,GAAG,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;;AAEpC,QAAA,IAAI,CAAC,KAAK,GAAG,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,GAAG,KAAK,CAAC,KAAK,KAAK,GAAG,GAAG,KAAK,CAAC;YAC7D,OAAO,IAAI,IAAI,GAAG;QACpB,OAAO,IAAI,IAAI,GAAG;IACpB;AACA,IAAA,MAAM,KAAK,GAAG,4BAA4B,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC;AACjE,IAAA,MAAM,IAAI,GAAG,KAAK,GAAG,CAAC,CAAC;AACvB,IAAA,MAAM,KAAK,GAAuB,KAAK,GAAG,CAAC,CAAC;AAC5C,IAAA,MAAM,IAAI,GAAuB,KAAK,GAAG,CAAC,CAAC;;AAG3C,IAAA,MAAM,CAAC,GAAG,IAAI,IAAI,CAChB,CAAA,EAAG,IAAI,CAAA,CAAA,EAAI,CAAA,CAAA,EAAI,KAAK,IAAI,CAAC,CAAA,CAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA,CAAA,EAAI,CAAA,CAAA,EAAI,IAAI,IAAI,CAAC,CAAA,CAAE,CAAC,KAAK,CAAC,EAAE,CAAC,CAAA,CAAE,CACrE;IAED,IAAI,KAAK,KAAK,SAAS,IAAI,IAAI,KAAK,SAAS,EAAE;AAC7C,QAAA,QACE,CAAC,CAAC,cAAc,EAAE,KAAK,IAAI;AAC3B,YAAA,CAAC,CAAC,WAAW,EAAE,GAAG,CAAC,KAAK,KAAK;AAC7B,YAAA,CAAC,CAAC,UAAU,EAAE,KAAK,IAAI;IAE3B;AACA,IAAA,OAAO,IAAI;AACb,CAAC;;;;"}

package/dist/predefined/brand/string/json-string.d.mts

@@ -0,0 +1,6 @@
+import { type Type } from '../../../type.mjs';
+/**
+ * @link https://github.com/validatorjs/validator.js/tree/v13.1.17?tab=readme-ov-file#validators
+ */
+export declare const jsonString: (defaultValue?: string) => Type<JsonString>;
+//# sourceMappingURL=json-string.d.mts.map

package/dist/predefined/brand/string/json-string.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-string.d.mts","sourceRoot":"","sources":["../../../../src/predefined/brand/string/json-string.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,UAAU,GACrB,eAAc,MAA0B,KACvC,IAAI,CAAC,UAAU,CAMd,CAAC"}

package/dist/predefined/brand/string/json-string.mjs

@@ -0,0 +1,24 @@
+import { isNonNullObject } from 'ts-data-forge';
+import { brandedString } from '../../../brand/branded-string.mjs';
+
+/**
+ * @link https://github.com/validatorjs/validator.js/tree/v13.1.17?tab=readme-ov-file#validators
+ */
+const jsonString = (defaultValue = defaultJsonString) => brandedString({
+    is: isJsonString,
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    defaultValue: defaultValue,
+    typeName: 'JsonString',
+});
+const defaultJsonString = '{}';
+const isJsonString = (str) => {
+    try {
+        return isNonNullObject(JSON.parse(str));
+    }
+    catch {
+        return false;
+    }
+};
+
+export { jsonString };
+//# sourceMappingURL=json-string.mjs.map

package/dist/predefined/brand/string/json-string.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-string.mjs","sources":["../../../../src/predefined/brand/string/json-string.mts"],"sourcesContent":[null],"names":[],"mappings":";;;AAIA;;AAEG;AACI,MAAM,UAAU,GAAG,CACxB,YAAA,GAAuB,iBAAiB,KAExC,aAAa,CAAC;AACZ,IAAA,EAAE,EAAE,YAAY;;AAEhB,IAAA,YAAY,EAAE,YAA0B;AACxC,IAAA,QAAQ,EAAE,YAAY;AACvB,CAAA;AAEH,MAAM,iBAAiB,GAAG,IAAI;AAE9B,MAAM,YAAY,GAAG,CAAC,GAAW,KAAuB;AACtD,IAAA,IAAI;QACF,OAAO,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACzC;AAAE,IAAA,MAAM;AACN,QAAA,OAAO,KAAK;IACd;AACF,CAAC;;;;"}

package/dist/predefined/brand/string/uuid.d.mts

@@ -0,0 +1,20 @@
+import { type Type } from '../../../type.mjs';
+/**
+ * @link https://github.com/validatorjs/validator.js/tree/v13.1.17?tab=readme-ov-file#validators
+ */
+export declare const uuid: <V extends UuidVersion | UuidVersionAdditionalOption>(options?: UuidValidatorOption<V>) => Type<UuidOf<V>>;
+type UuidVersionAdditionalOption = 'nil' | 'max' | 'all' | 'loose';
+type UuidOf<V extends UuidVersion | UuidVersionAdditionalOption> = TypeEq<V, 4> extends true ? Uuid4 : TypeEq<V, 6> extends true ? Uuid6 : TypeEq<V, 7> extends true ? Uuid7 : Uuid;
+export declare const uuidV4: (defaultValue?: string) => Type<Uuid4>;
+export declare const uuidV6: (defaultValue?: string) => Type<Uuid6>;
+export declare const uuidV7: (defaultValue?: string) => Type<Uuid7>;
+type UuidValidatorOption<V extends UuidVersion | UuidVersionAdditionalOption> = Readonly<{
+    /**
+     * @param version One of 1-8, 'nil', 'max', 'all' or 'loose'. The 'loose' option checks if the string is a UUID-like string with hexadecimal values, ignoring RFC9562.
+     */
+    version?: V;
+    typeName?: string;
+    defaultValue?: string;
+}>;
+export {};
+//# sourceMappingURL=uuid.d.mts.map

package/dist/predefined/brand/string/uuid.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.d.mts","sourceRoot":"","sources":["../../../../src/predefined/brand/string/uuid.mts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAE9C;;GAEG;AACH,eAAO,MAAM,IAAI,GAAI,CAAC,SAAS,WAAW,GAAG,2BAA2B,EACtE,UAAU,mBAAmB,CAAC,CAAC,CAAC,KAC/B,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAyBhB,CAAC;AAEF,KAAK,2BAA2B,GAAG,KAAK,GAAG,KAAK,GAAG,KAAK,GAAG,OAAO,CAAC;AAEnE,KAAK,MAAM,CAAC,CAAC,SAAS,WAAW,GAAG,2BAA2B,IAC7D,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GACrB,KAAK,GACL,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GACvB,KAAK,GACL,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,SAAS,IAAI,GACvB,KAAK,GACL,IAAI,CAAC;AAEf,eAAO,MAAM,MAAM,GAAI,eAAe,MAAM,KAAG,IAAI,CAAC,KAAK,CACrB,CAAC;AAErC,eAAO,MAAM,MAAM,GAAI,eAAe,MAAM,KAAG,IAAI,CAAC,KAAK,CACrB,CAAC;AAErC,eAAO,MAAM,MAAM,GAAI,eAAe,MAAM,KAAG,IAAI,CAAC,KAAK,CACrB,CAAC;AAErC,KAAK,mBAAmB,CAAC,CAAC,SAAS,WAAW,GAAG,2BAA2B,IAC1E,QAAQ,CAAC;IACP;;OAEG;IACH,OAAO,CAAC,EAAE,CAAC,CAAC;IAEZ,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC,CAAC"}

package/dist/predefined/brand/string/uuid.mjs

@@ -0,0 +1,55 @@
+import { brand } from '../../../brand/brand.mjs';
+import 'ts-data-forge';
+import { string } from '../../../primitives/string.mjs';
+
+/**
+ * @link https://github.com/validatorjs/validator.js/tree/v13.1.17?tab=readme-ov-file#validators
+ */
+const uuid = (options) => {
+    const defaultValue = options?.defaultValue ?? nilUuid;
+    const version = options?.version ?? 'all';
+    const regexp = uuidDef[version];
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    return brand({
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        baseType: string(defaultValue),
+        is: (s) => regexp.test(s),
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        defaultValue: defaultValue,
+        brandKeys: ['Uuid'],
+        typeName: options?.typeName ??
+            (version === 4
+                ? 'UuidV4'
+                : version === 6
+                    ? 'UuidV6'
+                    : version === 7
+                        ? 'UuidV7'
+                        : 'Uuid'),
+    });
+};
+const uuidV4 = (defaultValue) => uuid({ defaultValue, version: 4 });
+const uuidV6 = (defaultValue) => uuid({ defaultValue, version: 6 });
+const uuidV7 = (defaultValue) => uuid({ defaultValue, version: 7 });
+const nilUuid = '00000000-0000-0000-0000-000000000000';
+const uuidDef = {
+    1: /^[\da-f]{8}-[\da-f]{4}-1[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/iu,
+    2: /^[\da-f]{8}-[\da-f]{4}-2[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/iu,
+    3: /^[\da-f]{8}-[\da-f]{4}-3[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/iu,
+    4: /^[\da-f]{8}-[\da-f]{4}-4[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/iu,
+    5: /^[\da-f]{8}-[\da-f]{4}-5[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/iu,
+    6: /^[\da-f]{8}-[\da-f]{4}-6[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/iu,
+    7: /^[\da-f]{8}-[\da-f]{4}-7[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/iu,
+    8: /^[\da-f]{8}-[\da-f]{4}-8[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/iu,
+    // eslint-disable-next-line security/detect-unsafe-regex
+    nil: /^0{8}-(?:0{4}-){3}0{12}$/iu,
+    // eslint-disable-next-line security/detect-unsafe-regex
+    max: /^f{8}-(?:f{4}-){3}f{12}$/iu,
+    // eslint-disable-next-line security/detect-unsafe-regex
+    loose: /^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/iu,
+    // From https://github.com/uuidjs/uuid/blob/main/src/regex.js
+    // eslint-disable-next-line security/detect-unsafe-regex
+    all: /^(?:[\da-f]{8}-[\da-f]{4}-[1-8][\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}|0{8}-(?:0{4}-){3}0{12}|f{8}-(?:f{4}-){3}f{12})$/iu,
+};
+
+export { uuid, uuidV4, uuidV6, uuidV7 };
+//# sourceMappingURL=uuid.mjs.map

package/dist/predefined/brand/string/uuid.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.mjs","sources":["../../../../src/predefined/brand/string/uuid.mts"],"sourcesContent":[null],"names":[],"mappings":";;;;AAIA;;AAEG;AACI,MAAM,IAAI,GAAG,CAClB,OAAgC,KACb;AAGnB,IAAA,MAAM,YAAY,GAAG,OAAO,EAAE,YAAY,IAAI,OAAO;AACrD,IAAA,MAAM,OAAO,GAAG,OAAO,EAAE,OAAO,IAAI,KAAK;AACzC,IAAA,MAAM,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;;AAG/B,IAAA,OAAO,KAAK,CAAC;;AAEX,QAAA,QAAQ,EAAE,MAAM,CAAC,YAAY,CAAyB;QACtD,EAAE,EAAE,CAAC,CAAC,KAAa,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;;AAEjC,QAAA,YAAY,EAAE,YAAiB;QAC/B,SAAS,EAAE,CAAC,MAAM,CAAC;QACnB,QAAQ,EACN,OAAO,EAAE,QAAQ;aAChB,OAAO,KAAK;AACX,kBAAE;kBACA,OAAO,KAAK;AACZ,sBAAE;sBACA,OAAO,KAAK;AACZ,0BAAE;0BACA,MAAM,CAAC;AAClB,KAAA,CAAsC;AACzC;AAaO,MAAM,MAAM,GAAG,CAAC,YAAqB,KAC1C,IAAI,CAAC,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,EAAE;AAE5B,MAAM,MAAM,GAAG,CAAC,YAAqB,KAC1C,IAAI,CAAC,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,EAAE;AAE5B,MAAM,MAAM,GAAG,CAAC,YAAqB,KAC1C,IAAI,CAAC,EAAE,YAAY,EAAE,OAAO,EAAE,CAAC,EAAE;AAanC,MAAM,OAAO,GAAG,sCAAsC;AAEtD,MAAM,OAAO,GAAG;AACd,IAAA,CAAC,EAAE,oEAAoE;AACvE,IAAA,CAAC,EAAE,oEAAoE;AACvE,IAAA,CAAC,EAAE,oEAAoE;AACvE,IAAA,CAAC,EAAE,oEAAoE;AACvE,IAAA,CAAC,EAAE,oEAAoE;AACvE,IAAA,CAAC,EAAE,oEAAoE;AACvE,IAAA,CAAC,EAAE,oEAAoE;AACvE,IAAA,CAAC,EAAE,oEAAoE;;AAGvE,IAAA,GAAG,EAAE,4BAA4B;;AAEjC,IAAA,GAAG,EAAE,4BAA4B;;AAEjC,IAAA,KAAK,EAAE,8CAA8C;;;AAKrD,IAAA,GAAG,EAAE,0HAA0H;CACvH;;;;"}

package/dist/predefined/index.mjs

@@ -14,6 +14,10 @@ export { safeUint } from './brand/number/safe-uint.mjs';
 export { uint } from './brand/number/uint.mjs';
 export { uint16 } from './brand/number/uint16.mjs';
 export { uint32 } from './brand/number/uint32.mjs';
+export { email } from './brand/string/email.mjs';
+export { iso8601 } from './brand/string/iso-8601.mjs';
+export { jsonString } from './brand/string/json-string.mjs';
+export { uuid, uuidV4, uuidV6, uuidV7 } from './brand/string/uuid.mjs';
 export { int8 } from './int8.mjs';
 export { JsonObject, JsonPrimitive, JsonValue } from './json.mjs';
 export { nullable } from './nullable.mjs';

package/dist/predefined/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-fortress",
-  "version": "4.3.1",
+  "version": "4.4.0",
   "private": false,
   "keywords": [
     "typescript"

package/src/globals.d.mts

@@ -1,5 +1,22 @@
- 
-
 /// <reference types="ts-type-forge" />
 
 type PartialReadonly<T> = Partial<Readonly<T>>;
+
+type Iso8601 = Brand<string, 'Iso8601'>;
+
+type Email = Brand<string, 'Email'>;
+
+type JsonString = Brand<string, 'JsonString'>;
+
+type UuidVersion = UintRangeInclusive<1, 8>;
+
+type UuidBaseString<V extends UuidVersion = UuidVersion> =
+  `${string}-${string}-${V}${string}-${string}-${string}`;
+
+type Uuid = Brand<UuidBaseString, 'Uuid'>;
+
+type Uuid4 = Brand<UuidBaseString<4>, 'Uuid'>;
+
+type Uuid6 = Brand<UuidBaseString<6>, 'Uuid'>;
+
+type Uuid7 = Brand<UuidBaseString<7>, 'Uuid'>;

package/src/predefined/brand/index.mts

@@ -1 +1,2 @@
 export * from './number/index.mjs';
+export * from './string/index.mjs';

package/src/predefined/brand/string/email.mts

@@ -0,0 +1,25 @@
+import { brandedString } from '../../../brand/index.mjs';
+import { type Type } from '../../../type.mjs';
+
+/**
+ * @link https://html.spec.whatwg.org/multipage/input.html#valid-e-mail-address
+ */
+export const email = (defaultValue?: string): Type<Email> =>
+  brandedString({
+    is: (s): s is Email => regexpEmailAddress.test(s),
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    defaultValue: (defaultValue ?? defaultEmail) as Email,
+    typeName: 'Email',
+  });
+
+const defaultEmail = 'ts-f.o.r.t.r.e.s.s@gmail.com';
+
+const regexpEmailAddress =
+  // eslint-disable-next-line security/detect-unsafe-regex
+  /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/gu;
+
+if (import.meta.vitest !== undefined) {
+  test('defaultEmail', () => {
+    expect(defaultEmail).toMatch(regexpEmailAddress);
+  });
+}

package/src/predefined/brand/string/email.test.mts

@@ -0,0 +1,88 @@
+/* cSpell:disable */
+
+import { expectType } from 'ts-data-forge';
+import { type TypeOf } from '../../../type.mjs';
+import { email } from './email.mjs';
+
+// https://github.com/validatorjs/validator.js/blob/13.15.15/test/validators.test.js
+
+const validSamples = [
+  'foo@bar.com',
+  // 'x@x.au',
+  // 'foo@bar.com.au',
+  // 'foo+bar@bar.com',
+  // 'hans.m端ller@test.com',
+  // 'hans@m端ller.com',
+  // 'test|123@m端ller.com',
+  // 'test123+ext@gmail.com',
+  // 'some.name.midd.leNa.me.and.locality+extension@GoogleMail.com',
+  // '"foobar"@example.com',
+  // '"  foo  m端ller "@example.com',
+  // '"foo\\@bar"@example.com',
+  // `${'a'.repeat(64)}@${'a'.repeat(63)}.com`,
+  // `${'a'.repeat(31)}@gmail.com`,
+  // 'test@gmail.com',
+  // 'test.1@gmail.com',
+  // 'test@1337.com',
+] as const satisfies readonly string[];
+
+const invalidSamples = [
+  'invalidemail@',
+  'invalid.com',
+  '@invalid.com',
+  'foo@bar.com.',
+  'foo@_bar.com',
+  'somename@ｇｍａｉｌ.com',
+  'foo@bar.co.uk.',
+  // 'z@co.c',
+  'ｇｍａｉｌｇｍａｉｌｇｍａｉｌｇｍａｉｌｇｍａｉｌ@gmail.com',
+  `${'a'.repeat(64)}@${'a'.repeat(251)}.com`,
+  `${'a'.repeat(65)}@${'a'.repeat(250)}.com`,
+  `${'a'.repeat(64)}@${'a'.repeat(64)}.com`,
+  // `${'a'.repeat(64)}@${'a'.repeat(63)}.${'a'.repeat(63)}.${'a'.repeat(63)}.${'a'.repeat(58)}.com`,
+  'test1@invalid.co m',
+  'test2@invalid.co m',
+  'test3@invalid.co m',
+  'test4@invalid.co m',
+  'test5@invalid.co m',
+  'test6@invalid.co m',
+  'test7@invalid.co m',
+  'test8@invalid.co m',
+  'test9@invalid.co m',
+  'test10@invalid.co m',
+  'test11@invalid.co m',
+  'test12@invalid.co　m',
+  'test13@invalid.co　m',
+  // 'multiple..dots@stillinvalid.com',
+  'test123+invalid! sub_address@gmail.com',
+  // 'gmail...ignores...dots...@gmail.com',
+  // 'ends.with.dot.@gmail.com',
+  // 'multiple..dots@gmail.com',
+  'wrong()[]",:;<>@@gmail.com',
+  '"wrong()[]",:;<>@@gmail.com',
+  'username@domain.com�',
+  'username@domain.com©',
+  'nbsp test@test.com',
+  'nbsp_test@te st.com',
+  'nbsp_test@test.co m',
+  '"foobar@gmail.com',
+  '"foo"bar@gmail.com',
+  'foo"bar"@gmail.com',
+] as const satisfies readonly string[];
+
+describe('email', () => {
+  const baseType = email();
+
+  type Iso8601Type = TypeOf<typeof baseType>;
+
+  expectType<Iso8601Type, string>('<=');
+  expectType<typeof baseType.defaultValue, Iso8601Type>('=');
+
+  test.each(validSamples)('should accept $0', (e) => {
+    expect(baseType.is(e)).toBe(true);
+  });
+
+  test.each(invalidSamples)('should reject $0', (e) => {
+    expect(baseType.is(e)).toBe(false);
+  });
+});

package/src/predefined/brand/string/index.mts

@@ -0,0 +1,4 @@
+export * from './email.mjs';
+export * from './iso-8601.mjs';
+export * from './json-string.mjs';
+export * from './uuid.mjs';

package/src/predefined/brand/string/iso-8601.mts

@@ -0,0 +1,97 @@
+import { brandedString } from '../../../brand/index.mjs';
+import { boolean, string } from '../../../primitives/index.mjs';
+import { record } from '../../../record/index.mjs';
+import { type Type, type TypeOf } from '../../../type.mjs';
+
+/**
+ * @link https://github.com/validatorjs/validator.js/tree/v13.1.17?tab=readme-ov-file#validators
+ * @link https://developer.mozilla.org/ja/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString
+ * @link https://tc39.es/ecma262/multipage/numbers-and-dates.html#sec-date-time-string-format
+ */
+export const iso8601 = (options?: ISO8601ValidatorOption): Type<Iso8601> => {
+  const filledOptions = ISO8601ValidatorOption.fill(options);
+  const is = isISO8601(filledOptions);
+
+  return brandedString({
+    is,
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    defaultValue: filledOptions.defaultValue as Iso8601,
+    typeName: 'Iso8601',
+  });
+};
+
+const ISO8601ValidatorOption = record({
+  /**
+   *  If strict is true, date strings with invalid dates like 2009-02-29 will be invalid.
+   */
+  strict: boolean(false),
+
+  /**
+   * If strictSeparator is true, date strings with date and time separated by anything other than a T will be invalid.
+   */
+  strictSeparator: boolean(false),
+
+  /**
+   * @default `new Date().toISOString()`
+   */
+  defaultValue: string(new Date().toISOString()),
+});
+
+type ISO8601ValidatorOption = TypeOf<typeof ISO8601ValidatorOption>;
+
+const isISO8601 =
+  (options?: Partial<StrictOmit<ISO8601ValidatorOption, 'defaultValue'>>) =>
+  (str: string): str is Iso8601 => {
+    const filledOptions = ISO8601ValidatorOption.fill(options);
+
+    const check = filledOptions.strictSeparator
+      ? regexpIso8601StrictSeparator.test(str)
+      : regexpIso8601.test(str);
+
+    if (check && filledOptions.strict) return isValidDate(str);
+    return check;
+  };
+
+// from http://goo.gl/0ejHHW
+const regexpIso8601 =
+  // eslint-disable-next-line security/detect-unsafe-regex
+  /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-3])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))([\sT]((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([,.]\d+(?!:))?)?(\17[0-5]\d([,.]\d+)?)?([Zz]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/u;
+
+// same as above, except with a strict 'T' separator between date and time
+const regexpIso8601StrictSeparator =
+  // eslint-disable-next-line security/detect-unsafe-regex
+  /^([+-]?\d{4}(?!\d{2}\b))((-?)((0[1-9]|1[0-2])(\3([12]\d|0[1-9]|3[01]))?|W([0-4]\d|5[0-3])(-?[1-7])?|(00[1-9]|0[1-9]\d|[12]\d{2}|3([0-5]\d|6[1-6])))(T((([01]\d|2[0-3])((:?)[0-5]\d)?|24:?00)([,.]\d+(?!:))?)?(\17[0-5]\d([,.]\d+)?)?([Zz]|([+-])([01]\d|2[0-3]):?([0-5]\d)?)?)?)?$/u;
+
+const isValidDate = (str: string): boolean => {
+  // str must have passed the ISO8601 check
+  // this check is meant to catch invalid dates
+  // like 2009-02-31
+  // first check for ordinal dates
+  const ordinalMatch = /^(\d{4})-?(\d{3})([ T]\.*|$)/u.exec(str);
+  if (ordinalMatch !== null) {
+    const oYear = Number(ordinalMatch[1]);
+    const oDay = Number(ordinalMatch[2]);
+    // if is leap year
+    if ((oYear % 4 === 0 && oYear % 100 !== 0) || oYear % 400 === 0)
+      return oDay <= 366;
+    return oDay <= 365;
+  }
+  const match = /(\d{4})-?(\d{0,2})-?(\d*)/u.exec(str)?.map(Number);
+  const year = match?.[1];
+  const month: number | undefined = match?.[2];
+  const date: number | undefined = match?.[3];
+
+  // create a date object and compare
+  const d = new Date(
+    `${year}-${`0${month ?? 1}`.slice(-2)}-${`0${date ?? 1}`.slice(-2)}`,
+  );
+
+  if (month !== undefined && date !== undefined) {
+    return (
+      d.getUTCFullYear() === year &&
+      d.getUTCMonth() + 1 === month &&
+      d.getUTCDate() === date
+    );
+  }
+  return true;
+};

package/src/predefined/brand/string/iso-8601.test.mts

@@ -0,0 +1,168 @@
+import { expectType, Result } from 'ts-data-forge';
+import { type TypeOf } from '../../../type.mjs';
+import { validationErrorsToMessages } from '../../../utils/index.mjs';
+import { iso8601 } from './iso-8601.mjs';
+
+// https://www.myintervals.com/blog/iso-8601-date-validation/
+
+const validSamples = [
+  '2009-05-19 14:39',
+  '2009-12T12:34',
+  '2009',
+  '2009-05-19',
+  '20090519',
+  '2009123',
+  '2009-05',
+  '2009-123',
+  '2009-222',
+  '2009-001',
+  '2009-W01-1',
+  '2009-W51-1',
+  '2009-W511',
+  '2009-W33',
+  '2009W511',
+  '2009-05-19',
+  '2009-05-19 00:00',
+  '2009-05-19 14',
+  '2009-05-19 14:31',
+  '2009-05-19 14:39:22',
+  '2009-05-19T14:39Z',
+  '2009-W21-2',
+  '2009-W21-2T01:22',
+  '2009-139',
+  '2009-05-19 14:39:22-06:00',
+  '2009-05-19 14:39:22+0600',
+  '2009-05-19 14:39:22-01',
+  '20090621T0545Z',
+  '2007-04-06T00:00',
+  '2007-04-05T24:00',
+  '2010-02-18T16:23:48.5',
+  '2010-02-18T16:23:48,444',
+  '2010-02-18T16:23:48,3-06:00',
+  '2010-02-18T16:23.4',
+  '2010-02-18T16:23,25',
+  '2010-02-18T16:23.33+0600',
+  '2010-02-18T16.23334444',
+  '2010-02-18T16,2283',
+  '2009-05-19 143922.500',
+  '2009-05-19 1439,55',
+] as const satisfies readonly string[];
+
+const invalidSamples = [
+  '200905',
+  '2009367',
+  '2009-',
+  '2007-04-05T24:50',
+  '2009-000',
+  '2009-M511',
+  '2009M511',
+  '2009-05-19T14a39r',
+  '2009-05-19T14:3924',
+  '2009-0519',
+  '2009-05-1914:39',
+  '2009-05-19 14:',
+  '2009-05-19r14:39',
+  '2009-05-19 14a39a22',
+  '200912-01',
+  '2009-05-19 14:39:22+06a00',
+  '2009-05-19 146922.500',
+  '2010-02-18T16.5:23.35:48',
+  '2010-02-18T16:23.35:48',
+  '2010-02-18T16:23.35:48.45',
+  '2009-05-19 14.5.44',
+  '2010-02-18T16:23.33.600',
+  '2021-01-22T13:13:57.494677Z.',
+  '2010-02-18T16,25:23:48,44',
+] as const satisfies readonly string[];
+
+// https://tc39.es/ecma262/multipage/numbers-and-dates.html#sec-date-time-string-format
+
+const expandedYearFormats = [
+  '-271821-04-20T00:00:00Z', // 271822 B.C.
+  '-000001-01-01T00:00:00Z', // 2 B.C.
+  '+000000-01-01T00:00:00Z', // 1 B.C.
+  '+000001-01-01T00:00:00Z', // 1 A.D.
+  '+001970-01-01T00:00:00Z', // 1970 A.D.
+  '+002009-12-15T00:00:00Z', // 2009 A.D.
+  '+275760-09-13T00:00:00Z', // 275760 A.D.
+] as const satisfies readonly string[];
+
+describe('iso8601', () => {
+  const baseType = iso8601();
+  const baseDefault = baseType.defaultValue;
+
+  type Iso8601Type = TypeOf<typeof baseType>;
+
+  expectType<Iso8601Type, string>('<=');
+  expectType<typeof baseType.defaultValue, Iso8601Type>('=');
+
+  test.each(validSamples)('should accept $0', (e) => {
+    expect(baseType.is(e)).toBe(true);
+  });
+
+  test.each(invalidSamples)('should reject $0', (e) => {
+    expect(baseType.is(e)).toBe(false);
+  });
+
+  test.each(expandedYearFormats)(
+    'currently rejects expanded year formats $0',
+    (e) => {
+      expect(baseType.is(e)).toBe(false);
+    },
+  );
+
+  test('strict mode rejects calendar-invalid dates', () => {
+    const strictType = iso8601({
+      defaultValue: baseDefault,
+      strict: true,
+      strictSeparator: false,
+    });
+
+    expect(strictType.is('2008-02-29')).toBe(true);
+    expect(strictType.is('2009-02-29')).toBe(false);
+  });
+
+  test('strictSeparator mode enforces the T delimiter', () => {
+    const type = iso8601({
+      defaultValue: baseDefault,
+      strict: false,
+      strictSeparator: true,
+    });
+
+    expect(type.is('2009-05-19T14:39:22')).toBe(true);
+    expect(type.is('2009-05-19 14:39:22')).toBe(false);
+  });
+
+  test('validate yields detailed errors for invalid strings', () => {
+    const result = baseType.validate('not-an-iso-date');
+    expect(Result.isErr(result)).toBe(true);
+    if (!Result.isErr(result)) {
+      throw new Error('Expected validation failure');
+    }
+
+    expect(result.value).toStrictEqual([
+      {
+        path: [],
+        actualValue: 'not-an-iso-date',
+        expectedType: 'Iso8601',
+        typeName: 'Iso8601',
+        message: undefined,
+      },
+    ]);
+
+    expect(validationErrorsToMessages(result.value)).toStrictEqual([
+      'Expected <Iso8601>, got <string> type value "not-an-iso-date".',
+    ]);
+  });
+
+  test('fill and cast round trip valid values', () => {
+    const value = '2021-01-22T13:13:57.494677Z';
+
+    expect(baseType.fill(value)).toBe(value);
+    expect(() => baseType.cast(value)).not.toThrow();
+  });
+
+  test('fill falls back to default for invalid values', () => {
+    expect(baseType.fill('invalid')).toBe(baseDefault);
+  });
+});

package/src/predefined/brand/string/json-string.mts

@@ -0,0 +1,32 @@
+import { isNonNullObject } from 'ts-data-forge';
+import { brandedString } from '../../../brand/index.mjs';
+import { type Type } from '../../../type.mjs';
+
+/**
+ * @link https://github.com/validatorjs/validator.js/tree/v13.1.17?tab=readme-ov-file#validators
+ */
+export const jsonString = (
+  defaultValue: string = defaultJsonString,
+): Type<JsonString> =>
+  brandedString({
+    is: isJsonString,
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    defaultValue: defaultValue as JsonString,
+    typeName: 'JsonString',
+  });
+
+const defaultJsonString = '{}';
+
+const isJsonString = (str: string): str is JsonString => {
+  try {
+    return isNonNullObject(JSON.parse(str));
+  } catch {
+    return false;
+  }
+};
+
+if (import.meta.vitest !== undefined) {
+  test('defaultJsonString', () => {
+    expect(isJsonString(defaultJsonString)).toBe(true);
+  });
+}

package/src/predefined/brand/string/json-string.test.mts

@@ -0,0 +1,65 @@
+import { expectType, Result } from 'ts-data-forge';
+import { type TypeOf } from '../../../type.mjs';
+import { validationErrorsToMessages } from '../../../utils/index.mjs';
+import { jsonString } from './json-string.mjs';
+
+describe('jsonString', () => {
+  const baseType = jsonString();
+  const customDefault = jsonString('{"ok":true}');
+
+  type JsonStringType = TypeOf<typeof baseType>;
+  expectType<JsonStringType, string>('<=');
+  expectType<typeof baseType.defaultValue, JsonStringType>('=');
+
+  test('provides an object literal as default', () => {
+    expect(baseType.defaultValue).toBe('{}');
+    expect(customDefault.defaultValue).toBe('{"ok":true}');
+  });
+
+  test('recognizes valid JSON objects and arrays', () => {
+    const samples = ['{"foo":1}', '{"nested":{"bar":[1,2]}}', '[]'];
+
+    for (const sample of samples) {
+      expect(baseType.is(sample)).toBe(true);
+    }
+  });
+
+  test('rejects primitives and malformed JSON', () => {
+    const invalid = ['not-json', '{"unterminated"', '123', 'null'];
+
+    for (const sample of invalid) {
+      expect(baseType.is(sample)).toBe(false);
+    }
+  });
+
+  test('validate yields detailed errors for invalid strings', () => {
+    const result = baseType.validate('not-json');
+    expect(Result.isErr(result)).toBe(true);
+    if (!Result.isErr(result)) {
+      throw new Error('Expected validation failure');
+    }
+
+    expect(result.value).toStrictEqual([
+      {
+        path: [],
+        actualValue: 'not-json',
+        expectedType: 'JsonString',
+        typeName: 'JsonString',
+        message: undefined,
+      },
+    ]);
+
+    expect(validationErrorsToMessages(result.value)).toStrictEqual([
+      'Expected <JsonString>, got <string> type value "not-json".',
+    ]);
+  });
+
+  test('fill falls back to default for invalid input', () => {
+    expect(baseType.fill('invalid')).toBe(baseType.defaultValue);
+  });
+
+  test('cast returns parsed string when valid, throws otherwise', () => {
+    expect(baseType.cast('{"foo":1}')).toBe('{"foo":1}');
+    expect(() => baseType.cast('invalid')).toThrow('Expected');
+  });
+});

package/src/predefined/brand/string/uuid.mts

@@ -0,0 +1,97 @@
+import { brand } from '../../../brand/index.mjs';
+import { string } from '../../../primitives/index.mjs';
+import { type Type } from '../../../type.mjs';
+
+/**
+ * @link https://github.com/validatorjs/validator.js/tree/v13.1.17?tab=readme-ov-file#validators
+ */
+export const uuid = <V extends UuidVersion | UuidVersionAdditionalOption>(
+  options?: UuidValidatorOption<V>,
+): Type<UuidOf<V>> => {
+  type T = Brand<UuidBaseString, 'Uuid'>;
+
+  const defaultValue = options?.defaultValue ?? nilUuid;
+  const version = options?.version ?? 'all';
+  const regexp = uuidDef[version];
+
+  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+  return brand({
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    baseType: string(defaultValue) as Type<UuidBaseString>,
+    is: (s): s is T => regexp.test(s),
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    defaultValue: defaultValue as T,
+    brandKeys: ['Uuid'],
+    typeName:
+      options?.typeName ??
+      (version === 4
+        ? 'UuidV4'
+        : version === 6
+          ? 'UuidV6'
+          : version === 7
+            ? 'UuidV7'
+            : 'Uuid'),
+  }) satisfies Type<T> as Type<UuidOf<V>>;
+};
+
+type UuidVersionAdditionalOption = 'nil' | 'max' | 'all' | 'loose';
+
+type UuidOf<V extends UuidVersion | UuidVersionAdditionalOption> =
+  TypeEq<V, 4> extends true
+    ? Uuid4
+    : TypeEq<V, 6> extends true
+      ? Uuid6
+      : TypeEq<V, 7> extends true
+        ? Uuid7
+        : Uuid;
+
+export const uuidV4 = (defaultValue?: string): Type<Uuid4> =>
+  uuid({ defaultValue, version: 4 });
+
+export const uuidV6 = (defaultValue?: string): Type<Uuid6> =>
+  uuid({ defaultValue, version: 6 });
+
+export const uuidV7 = (defaultValue?: string): Type<Uuid7> =>
+  uuid({ defaultValue, version: 7 });
+
+type UuidValidatorOption<V extends UuidVersion | UuidVersionAdditionalOption> =
+  Readonly<{
+    /**
+     * @param version One of 1-8, 'nil', 'max', 'all' or 'loose'. The 'loose' option checks if the string is a UUID-like string with hexadecimal values, ignoring RFC9562.
+     */
+    version?: V;
+
+    typeName?: string;
+    defaultValue?: string;
+  }>;
+
+const nilUuid = '00000000-0000-0000-0000-000000000000';
+
+const uuidDef = {
+  1: /^[\da-f]{8}-[\da-f]{4}-1[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/iu,
+  2: /^[\da-f]{8}-[\da-f]{4}-2[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/iu,
+  3: /^[\da-f]{8}-[\da-f]{4}-3[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/iu,
+  4: /^[\da-f]{8}-[\da-f]{4}-4[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/iu,
+  5: /^[\da-f]{8}-[\da-f]{4}-5[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/iu,
+  6: /^[\da-f]{8}-[\da-f]{4}-6[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/iu,
+  7: /^[\da-f]{8}-[\da-f]{4}-7[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/iu,
+  8: /^[\da-f]{8}-[\da-f]{4}-8[\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}$/iu,
+
+  // eslint-disable-next-line security/detect-unsafe-regex
+  nil: /^0{8}-(?:0{4}-){3}0{12}$/iu,
+  // eslint-disable-next-line security/detect-unsafe-regex
+  max: /^f{8}-(?:f{4}-){3}f{12}$/iu,
+  // eslint-disable-next-line security/detect-unsafe-regex
+  loose: /^[\da-f]{8}(?:-[\da-f]{4}){3}-[\da-f]{12}$/iu,
+
+  // From https://github.com/uuidjs/uuid/blob/main/src/regex.js
+
+  // eslint-disable-next-line security/detect-unsafe-regex
+  all: /^(?:[\da-f]{8}-[\da-f]{4}-[1-8][\da-f]{3}-[89ab][\da-f]{3}-[\da-f]{12}|0{8}-(?:0{4}-){3}0{12}|f{8}-(?:f{4}-){3}f{12})$/iu,
+} as const;
+
+if (import.meta.vitest !== undefined) {
+  test('uuidNil', () => {
+    expect(nilUuid).toMatch(uuidDef.nil);
+  });
+}

package/src/predefined/brand/string/uuid.test.mts

@@ -0,0 +1,125 @@
+import { expectType, Result } from 'ts-data-forge';
+import { type TypeOf } from '../../../type.mjs';
+import { validationErrorsToMessages } from '../../../utils/index.mjs';
+import { uuid, uuidV4, uuidV6, uuidV7 } from './uuid.mjs';
+
+const nilUuid = '00000000-0000-0000-0000-000000000000';
+const maxUuid = 'ffffffff-ffff-ffff-ffff-ffffffffffff';
+const uuidV4Example = '550e8400-e29b-41d4-a716-446655440000';
+const uuidV6Example = '550e8400-e29b-61d4-a716-446655440000';
+const uuidV7Example = '550e8400-e29b-71d4-a716-446655440000';
+
+describe('uuid', () => {
+  const baseType = uuid();
+
+  type UuidType = TypeOf<typeof baseType>;
+  expectType<UuidType, string>('<=');
+  expectType<typeof baseType.defaultValue, UuidType>('=');
+
+  test('provides nil UUID as default', () => {
+    expect(baseType.defaultValue).toBe(nilUuid);
+  });
+
+  test('accepts multiple UUID flavours by default', () => {
+    const validSamples = [
+      uuidV4Example,
+      uuidV6Example,
+      uuidV7Example,
+      nilUuid,
+      maxUuid,
+    ];
+
+    for (const sample of validSamples) {
+      expect(baseType.is(sample)).toBe(true);
+    }
+  });
+
+  test('rejects malformed identifiers', () => {
+    const invalidSamples = [
+      'not-a-uuid',
+      '550e8400e29b41d4a716446655440000',
+      '550e8400-e29b-41d4-a716-44665544000',
+    ];
+
+    for (const sample of invalidSamples) {
+      expect(baseType.is(sample)).toBe(false);
+    }
+  });
+
+  test('validate surfaces details for invalid strings', () => {
+    const result = baseType.validate('not-a-uuid');
+    expect(Result.isErr(result)).toBe(true);
+    if (!Result.isErr(result)) {
+      throw new Error('Expected validation failure');
+    }
+
+    expect(result.value).toStrictEqual([
+      {
+        path: [],
+        actualValue: 'not-a-uuid',
+        expectedType: 'Uuid',
+        typeName: 'Uuid',
+        message: undefined,
+      },
+    ]);
+
+    expect(validationErrorsToMessages(result.value)).toStrictEqual([
+      'Expected <Uuid>, got <string> type value "not-a-uuid".',
+    ]);
+  });
+});
+
+describe('uuidV4', () => {
+  const v4Type = uuidV4();
+
+  type UuidV4Type = TypeOf<typeof v4Type>;
+  expectType<UuidV4Type, string>('<=');
+  expectType<typeof v4Type.defaultValue, UuidV4Type>('=');
+
+  test('recognizes version 4 UUIDs only', () => {
+    expect(v4Type.is(uuidV4Example)).toBe(true);
+    expect(v4Type.is(uuidV6Example)).toBe(false);
+  });
+
+  test('validate reports version mismatch', () => {
+    const result = v4Type.validate(uuidV6Example);
+    expect(Result.isErr(result)).toBe(true);
+    if (!Result.isErr(result)) {
+      throw new Error('Expected validation failure');
+    }
+
+    expect(result.value).toStrictEqual([
+      {
+        path: [],
+        actualValue: uuidV6Example,
+        expectedType: 'UuidV4',
+        typeName: 'UuidV4',
+        message: undefined,
+      },
+    ]);
+  });
+
+  test('fill returns default for invalid input', () => {
+    expect(v4Type.fill('invalid-uuid')).toBe(v4Type.defaultValue);
+  });
+});
+
+describe('uuidV6', () => {
+  const v6Type = uuidV6();
+
+  test('recognizes only version 6 UUIDs', () => {
+    expect(v6Type.is(uuidV6Example)).toBe(true);
+    expect(v6Type.is(uuidV4Example)).toBe(false);
+    expect(v6Type.is(uuidV7Example)).toBe(false);
+  });
+});
+
+describe('uuidV7', () => {
+  const v7Type = uuidV7();
+
+  test('recognizes only version 7 UUIDs', () => {
+    expect(v7Type.is(uuidV7Example)).toBe(true);
+    expect(v7Type.is(uuidV4Example)).toBe(false);
+    expect(v7Type.is(uuidV6Example)).toBe(false);
+  });
+});