@mionjs/type-formats 0.8.0-alpha.0

package/.dist/esm/src/string/dateTime.runtype.js

@@ -0,0 +1,83 @@
+import { registerFormatter, BaseRunTypeFormat, __ΩTypeFormat as ___TypeFormat } from "@mionjs/run-types";
+import { ReflectionKind } from "@deepkit/type";
+import { DateStringRunTypeFormat, __ΩDEFAULT_DATE_PARAMS as ___DEFAULT_DATE_PARAMS } from "./date.runtype.js";
+import { TimeStringRunTypeFormat, __ΩDEFAULT_TIME_FORMAT_PARAMS as ___DEFAULT_TIME_FORMAT_PARAMS } from "./time.runtype.js";
+import { stringIgnoreProps } from "./stringFormat.runtype.js";
+import { paramVal } from "../utils.js";
+class DateTimeRunTypeFormat extends BaseRunTypeFormat {
+  static id = "dateTime";
+  kind = ReflectionKind.string;
+  name = DateTimeRunTypeFormat.id;
+  dateFormatter;
+  timeFormatter;
+  constructor(parentPath) {
+    super(parentPath);
+    this.dateFormatter = new DateStringRunTypeFormat(this.getFormatPath("date"));
+    this.timeFormatter = new TimeStringRunTypeFormat(this.getFormatPath("time"));
+  }
+  getIgnoredProps() {
+    return stringIgnoreProps;
+  }
+  emitIsType(comp, rt) {
+    const params = this.getParams(rt);
+    const fnID = comp.fnID;
+    const fmtName = this.getFormatName();
+    const vλl = comp.vλl;
+    const splitChar = paramVal(params.splitChar);
+    const vDatePart = "datePart" + this.getFormatNestLevel();
+    const vTimePart = "timePart" + this.getFormatNestLevel();
+    const vSplitPos = "splitPos" + this.getFormatNestLevel();
+    const dateCode = this.dateFormatter.compileFormat(fnID, comp, rt, params.date, vDatePart, fmtName);
+    const timeCode = this.timeFormatter.compileFormat(fnID, comp, rt, params.time, vTimePart, fmtName);
+    const returnCode = this.isRootFormat() ? `return true;` : "";
+    const code = `
+            const ${vSplitPos} = ${vλl}.indexOf('${splitChar}');
+            if (${vSplitPos} === -1) return false;
+            const ${vDatePart} = ${vλl}.substring(0, ${vSplitPos});
+            const ${vTimePart} = ${vλl}.substring(${vSplitPos} + 1);
+            if (!(${dateCode.code})) return false;
+            if (!(${timeCode.code})) return false;
+            ${returnCode}
+        `;
+    return { code, type: "S" };
+  }
+  emitIsTypeErrors(comp, rt) {
+    const params = this.getParams(rt);
+    const fnID = comp.fnID;
+    const fmtName = this.getFormatName();
+    const splitChar = paramVal(params.splitChar);
+    const errFn = this.getCallJitFormatErr(comp, rt, this, false);
+    const vλl = comp.vλl;
+    const vDatePart = "datePart";
+    const vTimePart = "timePart";
+    const vSplitPos = "splitPos";
+    const dateCode = this.dateFormatter.compileFormat(fnID, comp, rt, params.date, vDatePart, fmtName);
+    const timeCode = this.timeFormatter.compileFormat(fnID, comp, rt, params.time, vTimePart, fmtName);
+    const code = `
+            const ${vSplitPos} = ${vλl}.indexOf('${splitChar}');
+            if (${vSplitPos} === -1) ${errFn("splitChar", splitChar)};
+            const ${vDatePart} = ${vλl}.substring(0, ${vSplitPos});
+            const ${vTimePart} = ${vλl}.substring(${vSplitPos} + 1);
+            ${dateCode.code ? `${dateCode.code};` : ""}
+            ${timeCode.code ? `${timeCode.code};` : ""}
+        `;
+    return { code, type: "S" };
+  }
+  _mock(opts, rt) {
+    const params = this.getParams(rt);
+    const splitChar = paramVal(params.splitChar);
+    const datePart = this.dateFormatter.mock(opts, rt, params.date);
+    const timePart = this.timeFormatter.mock(opts, rt, params.time);
+    return `${datePart}${splitChar}${timePart}`;
+  }
+}
+const DATE_TIME_RUN_TYPE_FORMATTER = registerFormatter(new DateTimeRunTypeFormat());
+const __ΩDEFAULT_DATE_TIME_PARAMS = [() => ___DEFAULT_DATE_PARAMS, "date", () => ___DEFAULT_TIME_FORMAT_PARAMS, "time", "T", "splitChar", "DEFAULT_DATE_TIME_PARAMS", `Pn!4"n#4$.%4&Mw'y`];
+const __ΩFormatStringDateTime = ["P", () => ___TypeFormat, () => DateTimeRunTypeFormat.id, () => __ΩDEFAULT_DATE_TIME_PARAMS, "dateTime", "FormatStringDateTime", 'PMc!&i#Pn$e"!K.%o"%w&y'];
+export {
+  DATE_TIME_RUN_TYPE_FORMATTER,
+  DateTimeRunTypeFormat,
+  __ΩDEFAULT_DATE_TIME_PARAMS,
+  __ΩFormatStringDateTime
+};
+//# sourceMappingURL=dateTime.runtype.js.map

package/.dist/esm/src/string/dateTime.runtype.js.map

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

package/.dist/esm/src/string/defaultStringFormats.runtype.d.ts

@@ -0,0 +1,45 @@
+import { FormatString } from './stringFormat.runtype.ts';
+import { StringParams } from '@mionjs/core';
+export declare const ALPHANUMERIC_REGEX: RegExp;
+export declare const ALPHA_REGEX: RegExp;
+export declare const NUMERIC_REGEX: RegExp;
+type DEFAULT_ALPHA_NUM_PARAMS = {
+    pattern: {
+        val: typeof ALPHANUMERIC_REGEX;
+        mockSamples: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+        errorMessage: 'only alphanumeric values are allowed';
+    };
+};
+type DEFAULT_ALPHA_PARAMS = {
+    pattern: {
+        val: typeof ALPHA_REGEX;
+        mockSamples: 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+        errorMessage: 'only alphabetic values are allowed';
+    };
+};
+type DEFAULT_NUMERIC_PARAMS = {
+    pattern: {
+        val: typeof NUMERIC_REGEX;
+        mockSamples: '0123456789';
+        errorMessage: 'only numeric values are allowed';
+    };
+};
+export type FormatAlphaNumeric<P extends StringParams = {}> = FormatString<P & DEFAULT_ALPHA_NUM_PARAMS>;
+export type FormatAlpha<P extends StringParams = {}> = FormatString<P & DEFAULT_ALPHA_PARAMS>;
+export type FormatNumeric<P extends StringParams = {}> = FormatString<P & DEFAULT_NUMERIC_PARAMS>;
+export type FormatLowercase<P extends StringParams = {}> = FormatString<P & {
+    lowercase: true;
+}>;
+export type FormatUppercase<P extends StringParams = {}> = FormatString<P & {
+    uppercase: true;
+}>;
+export type FormatCapitalize<P extends StringParams = {}> = FormatString<P & {
+    capitalize: true;
+}>;
+export {};
+export declare type __ΩFormatAlphaNumeric = any[];
+export declare type __ΩFormatAlpha = any[];
+export declare type __ΩFormatNumeric = any[];
+export declare type __ΩFormatLowercase = any[];
+export declare type __ΩFormatUppercase = any[];
+export declare type __ΩFormatCapitalize = any[];

package/.dist/esm/src/string/defaultStringFormats.runtype.js

@@ -0,0 +1,25 @@
+import { __ΩFormatString as ___FormatString } from "./stringFormat.runtype.js";
+const ALPHANUMERIC_REGEX = /^[\p{L}\p{N}]+$/u;
+const ALPHA_REGEX = /^[\p{L}]+$/u;
+const NUMERIC_REGEX = /^[\p{N}]+$/u;
+const __ΩDEFAULT_ALPHA_NUM_PARAMS = [() => ALPHANUMERIC_REGEX, "val", "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", "mockSamples", "only alphanumeric values are allowed", "errorMessage", "pattern", "DEFAULT_ALPHA_NUM_PARAMS", `PPi!4".#4$.%4&M4'Mw(y`];
+const __ΩDEFAULT_ALPHA_PARAMS = [() => ALPHA_REGEX, "val", "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", "mockSamples", "only alphabetic values are allowed", "errorMessage", "pattern", "DEFAULT_ALPHA_PARAMS", `PPi!4".#4$.%4&M4'Mw(y`];
+const __ΩDEFAULT_NUMERIC_PARAMS = [() => NUMERIC_REGEX, "val", "0123456789", "mockSamples", "only numeric values are allowed", "errorMessage", "pattern", "DEFAULT_NUMERIC_PARAMS", `PPi!4".#4$.%4&M4'Mw(y`];
+const __ΩFormatAlphaNumeric = ["P", () => ___FormatString, () => __ΩDEFAULT_ALPHA_NUM_PARAMS, "FormatAlphaNumeric", 'PMc!Pe"!n#Ko""w$y'];
+const __ΩFormatAlpha = ["P", () => ___FormatString, () => __ΩDEFAULT_ALPHA_PARAMS, "FormatAlpha", 'PMc!Pe"!n#Ko""w$y'];
+const __ΩFormatNumeric = ["P", () => ___FormatString, () => __ΩDEFAULT_NUMERIC_PARAMS, "FormatNumeric", 'PMc!Pe"!n#Ko""w$y'];
+const __ΩFormatLowercase = ["P", () => ___FormatString, true, "lowercase", "FormatLowercase", 'PMc!Pe"!P.#4$MKo""w%y'];
+const __ΩFormatUppercase = ["P", () => ___FormatString, true, "uppercase", "FormatUppercase", 'PMc!Pe"!P.#4$MKo""w%y'];
+const __ΩFormatCapitalize = ["P", () => ___FormatString, true, "capitalize", "FormatCapitalize", 'PMc!Pe"!P.#4$MKo""w%y'];
+export {
+  ALPHANUMERIC_REGEX,
+  ALPHA_REGEX,
+  NUMERIC_REGEX,
+  __ΩFormatAlpha,
+  __ΩFormatAlphaNumeric,
+  __ΩFormatCapitalize,
+  __ΩFormatLowercase,
+  __ΩFormatNumeric,
+  __ΩFormatUppercase
+};
+//# sourceMappingURL=defaultStringFormats.runtype.js.map

package/.dist/esm/src/string/defaultStringFormats.runtype.js.map

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

package/.dist/esm/src/string/domain.runtype.d.ts

@@ -0,0 +1,72 @@
+import { BaseRunType, JitFnCompiler, JitErrorsFnCompiler, JitCode, JitFnID, StrNumber, BaseRunTypeFormat, RunTypeOptions, TypeFormat } from '@mionjs/run-types';
+import { ReflectionKind } from '@deepkit/type';
+import { FormatParams_Domain, Samples } from '@mionjs/core';
+export declare const DOMAIN_PATTERN: RegExp;
+export declare const DOMAIN_PATTERN_UNICODE: RegExp;
+export declare const DOMAIN_PATTERN_PUNYCODE: RegExp;
+export declare const DOMAIN_ALLOWED_CHARS_PATTERN: RegExp;
+export declare const TLD_ALLOWED_CHARS_PATTERN: RegExp;
+export declare class DomainRunTypeFormat extends BaseRunTypeFormat<FormatParams_Domain> {
+    static id: "domain";
+    kind: ReflectionKind;
+    name: "domain";
+    private rootFormatter;
+    private nameFormatter;
+    private tldFormatter;
+    constructor(parentPath?: StrNumber[]);
+    canEmbedFormatterCode(fnID: JitFnID, rt: BaseRunType, p?: FormatParams_Domain): boolean;
+    getIgnoredProps(): string[] | undefined;
+    emitIsType(comp: JitFnCompiler, rt: BaseRunType): JitCode;
+    emitIsTypeErrors(comp: JitErrorsFnCompiler, rt: BaseRunType): JitCode;
+    _mock(opts: RunTypeOptions, rt: BaseRunType): string;
+    private hasNoConstrains;
+    private mockName;
+    private mockTld;
+    emitFormat(comp: JitFnCompiler): JitCode;
+    _formatMockedValue(opts: RunTypeOptions, _rt: BaseRunType, val: any): string;
+    validateParams(rt: BaseRunType, params: FormatParams_Domain): void;
+}
+export declare const DOMAIN_RUN_TYPE_FORMATTER: DomainRunTypeFormat;
+export type DEFAULT_DOMAIN_PARAMS<P extends RegExp = typeof DOMAIN_PATTERN, S extends Samples = ['ggle.com', 'mion.io', 'mionkit.io', 'yahuu.net', 'fbook.com', 'wiki.org', 'ms.net']> = {
+    maxLength: 253;
+    minLength: 5;
+    pattern: {
+        val: P;
+        mockSamples: S;
+        errorMessage: 'invalid domain';
+    };
+};
+export type DEFAULT_DMM_TLD_PARAMS<P extends RegExp = typeof TLD_ALLOWED_CHARS_PATTERN, S extends Samples = ['com', 'org', 'net', 'io', 'app', 'co', 'dev', 'tech', 'ai', 'mion', 'co.uk', 'com.au', 'com.br']> = {
+    maxLength: 12;
+    minLength: 2;
+    pattern: {
+        val: P;
+        mockSamples: S;
+        errorMessage: 'top level domain can only contain letters and dots';
+    };
+};
+export type DEFAULT_DOM_NAME_PARAMS<P extends RegExp = typeof DOMAIN_ALLOWED_CHARS_PATTERN, S extends Samples = ['domain', 'ggle', 'fbook', 'mion', 'prot', 'yahuu', 'hello', 'world', 'example', 'wiki', 'mionkit']> = {
+    maxLength: 63;
+    minLength: 2;
+    pattern: {
+        val: P;
+        mockSamples: S;
+        errorMessage: 'domain names can only contain letters, numbers and hyphens';
+    };
+};
+export type DEFAULT_STRICT_DOMAIN_PARAMS = {
+    maxParts: 6;
+    minParts: 2;
+    names: DEFAULT_DOM_NAME_PARAMS;
+    tld: DEFAULT_DMM_TLD_PARAMS;
+    maxLength: 253;
+    minLength: 5;
+};
+export type FormatDomain<DP extends FormatParams_Domain = DEFAULT_DOMAIN_PARAMS> = TypeFormat<string, 'domain', DP, 'domain'>;
+export type FormatDomainStrict<D extends Partial<FormatParams_Domain> = {}> = FormatDomain<DEFAULT_STRICT_DOMAIN_PARAMS & D>;
+export declare type __ΩDEFAULT_DOMAIN_PARAMS = any[];
+export declare type __ΩDEFAULT_DMM_TLD_PARAMS = any[];
+export declare type __ΩDEFAULT_DOM_NAME_PARAMS = any[];
+export declare type __ΩDEFAULT_STRICT_DOMAIN_PARAMS = any[];
+export declare type __ΩFormatDomain = any[];
+export declare type __ΩFormatDomainStrict = any[];

package/.dist/esm/src/string/domain.runtype.js

@@ -0,0 +1,248 @@
+import { registerFormatter, BaseRunTypeFormat, JitFunctions, random, randomItem, __ΩTypeFormat as ___TypeFormat } from "@mionjs/run-types";
+import { ReflectionKind } from "@deepkit/type";
+import { StringRunTypeFormat, stringIgnoreProps } from "./stringFormat.runtype.js";
+import { NAME_SAMPLES, NAME_CHARS, TLD_SAMPLES, TLD_CHARS } from "../constants.mock.js";
+import { paramVal } from "../utils.js";
+const DOMAIN_PATTERN = /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,63}$/;
+const DOMAIN_PATTERN_UNICODE = /^(?:[\p{L}\p{N}](?:[\p{L}\p{N}-]{0,61}[\p{L}\p{N}])?\.)+[a-zA-Z]{2,63}$/u;
+const DOMAIN_PATTERN_PUNYCODE = /^(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z0-9-]{2,63}$/;
+const DOMAIN_ALLOWED_CHARS_PATTERN = /^[a-zA-Z0-9-]+$/;
+const TLD_ALLOWED_CHARS_PATTERN = /^[a-zA-Z]+(\.[a-zA-Z]+)?$/;
+const tldAllowedChars = {
+  val: TLD_CHARS,
+  errorMessage: "only alphabetical characters allowed"
+};
+const namesAllowedChars = {
+  val: NAME_CHARS,
+  errorMessage: "only alphabetical characters and hyphens allowed"
+};
+class DomainRunTypeFormat extends BaseRunTypeFormat {
+  static id = "domain";
+  kind = ReflectionKind.string;
+  name = DomainRunTypeFormat.id;
+  // Formatter instances as class variables
+  rootFormatter;
+  nameFormatter;
+  tldFormatter;
+  constructor(parentPath) {
+    super(parentPath);
+    const domainPath = this.getFormatPath();
+    const namePath = this.getFormatPath("names");
+    const tldPath = this.getFormatPath("tld");
+    this.rootFormatter = new StringRunTypeFormat(domainPath);
+    this.nameFormatter = new StringRunTypeFormat(namePath);
+    this.tldFormatter = new StringRunTypeFormat(tldPath);
+  }
+  canEmbedFormatterCode(fnID, rt, p) {
+    const params = p || this.getParams(rt);
+    if (fnID === JitFunctions.isType.id || fnID === JitFunctions.typeErrors.id)
+      return super.canEmbedFormatterCode(fnID, rt) && !!params.pattern;
+    return super.canEmbedFormatterCode(fnID, rt);
+  }
+  getIgnoredProps() {
+    return stringIgnoreProps;
+  }
+  emitIsType(comp, rt) {
+    const params = this.getParams(rt);
+    const fnID = comp.fnID;
+    const fmtName = this.getFormatName();
+    if (params.pattern)
+      return this.rootFormatter.compileFormat(fnID, comp, rt, params, comp.vλl, fmtName);
+    const vλl = comp.vλl;
+    const vName = "name" + this.getFormatNestLevel();
+    const vTld = "tld" + this.getFormatNestLevel();
+    const vCount = "count" + this.getFormatNestLevel();
+    const vStart = "start" + this.getFormatNestLevel();
+    const vPos = "pos" + this.getFormatNestLevel();
+    const rootCode = this.rootFormatter.compileFormat(fnID, comp, rt, params, vλl, fmtName);
+    const nameCode = this.nameFormatter.compileFormat(fnID, comp, rt, params.names, vName, fmtName);
+    const tldCode = this.tldFormatter.compileFormat(fnID, comp, rt, params.tld, vTld, fmtName);
+    const maxPartsCode = params.maxParts ? `if (${vCount} > ${params.maxParts}) return false;` : "";
+    const minPartsCode = params.minParts ? `if (${vCount} < ${params.minParts}) return false;` : "";
+    const rootSafeCode = rootCode.code ? `if (!(${rootCode.code})) return false;` : "";
+    const tldSafeCode = tldCode.code ? `const ${vTld} = ${vλl}.substring(${vStart}); if (!(${tldCode.code})) return false;` : "";
+    const returnCode = this.isRootFormat() ? `return true;` : "";
+    const skipCount = !maxPartsCode && !minPartsCode && !tldCode.code;
+    const code = `
+            ${rootSafeCode}
+            let ${vCount} = 1; let ${vStart} = 0; let ${vPos}; let ${vName};
+            while ((${vPos} = ${vλl}.indexOf('.', ${vStart})) !== -1) {
+                ${vName} = ${vλl}.substring(${vStart}, ${vPos});
+                ${!params.names?.allowedValues ? `if (${vName}.startsWith('-') || ${vName}.endsWith('-')) return false;` : ""}
+                if (!(${nameCode.code})) return false;
+                ${vStart} = ${vPos} + 1;
+                ${!skipCount ? `${vCount}++;` : ""}
+            }
+            ${maxPartsCode}
+            ${minPartsCode}
+            ${tldSafeCode}
+            ${returnCode}
+        `;
+    return { code, type: "S" };
+  }
+  emitIsTypeErrors(comp, rt) {
+    const params = this.getParams(rt);
+    const fnID = comp.fnID;
+    const fmtName = this.getFormatName();
+    if (params.pattern)
+      return this.rootFormatter.compileFormat(fnID, comp, rt, params, comp.vλl, fmtName);
+    const errFn = this.getCallJitFormatErr(comp, rt, this, false);
+    const vλl = comp.vλl;
+    const vName = "name" + this.getFormatNestLevel();
+    const vTld = "tld" + this.getFormatNestLevel();
+    const vCount = "count" + this.getFormatNestLevel();
+    const vStart = "start" + this.getFormatNestLevel();
+    const vPos = "pos" + this.getFormatNestLevel();
+    const rootCode = this.rootFormatter.compileFormat(fnID, comp, rt, params, vλl, fmtName);
+    const nameCode = this.nameFormatter.compileFormat(fnID, comp, rt, params.names, vName, fmtName, vCount);
+    const tldCode = this.tldFormatter.compileFormat(fnID, comp, rt, params.tld, vTld, fmtName);
+    const maxPartsCode = params.maxParts ? `if (${vCount} > ${params.maxParts}) ${errFn("maxParts", paramVal(params.maxParts))};` : "";
+    const minPartsCode = params.minParts ? `if (${vCount} < ${params.minParts}) ${errFn("minParts", paramVal(params.minParts))};` : "";
+    const tldSafeCode = tldCode.code ? `const ${vTld} = ${vλl}.substring(${vStart}); ${tldCode.code};` : "";
+    const skipCount = !maxPartsCode && !minPartsCode && !tldCode.code;
+    const code = `
+            ${rootCode.code};
+            let ${vCount} = 0; let ${vStart} = 0; let ${vPos}; let ${vName};
+            while ((${vPos} = ${vλl}.indexOf('.', ${vStart})) !== -1) {
+                ${vName} = ${vλl}.substring(${vStart}, ${vPos});
+                ${!params.names?.allowedValues ? `if (${vName}.startsWith('-') || ${vName}.endsWith('-')) ${errFn("hyphen", "name")};` : ""}
+                ${nameCode.code};
+                ${vStart} = ${vPos} + 1;
+                ${!skipCount ? `${vCount}++;` : ""}
+            }
+            ${!skipCount ? `${vCount}++;` : ""}
+            ${maxPartsCode}
+            ${minPartsCode}
+            ${tldSafeCode};
+        `;
+    return { code, type: "S" };
+  }
+  _mock(opts, rt) {
+    const params = this.getParams(rt);
+    if (params.pattern)
+      return this.rootFormatter.mock(opts, rt, params);
+    const maxParts = paramVal(params.maxParts || 6);
+    const minParts = paramVal(params.minParts || 2);
+    const maxLength = paramVal(params.maxLength || 253);
+    const minLength = paramVal(params.minLength || 3);
+    let tld = this.mockTld(opts, rt, params.tld);
+    const tldParts = tld.split(".");
+    while (tldParts.length > 1 && tldParts.length >= maxParts)
+      tldParts.shift();
+    tld = tldParts.join(".");
+    const singleNameMax = tldParts.length + 1;
+    const noNormalMax = Math.random() < 0.2 ? maxParts : singleNameMax;
+    const maxRandom = noNormalMax - tldParts.length;
+    const minRandom = minParts - paramVal(tldParts.length);
+    const maxRandomParts = random(minRandom, maxRandom);
+    const parts = [];
+    parts.push(this.mockName(opts, rt, params.names));
+    let name = parts[0];
+    let domain = `${name}.${tld}`;
+    while (domain.length < maxLength && parts.length < maxRandomParts || domain.length < minLength) {
+      parts.push(this.mockName(opts, rt, params.names));
+      name = parts.join(".");
+      domain = `${name}.${tld}`;
+    }
+    return domain;
+  }
+  hasNoConstrains(params) {
+    return !params.allowedChars && !params.disallowedChars && !params.pattern && !params.allowedValues;
+  }
+  mockName(opts, rt, params) {
+    const hasParams = !!Object.keys(params).length;
+    if (!hasParams)
+      return randomItem(NAME_SAMPLES);
+    const defaultParams = {
+      ...params,
+      maxLength: params.maxLength ?? 63,
+      minLength: params.minLength ?? 2,
+      pattern: params.pattern,
+      allowedValues: params.allowedValues,
+      disallowedValues: params.disallowedValues,
+      allowedChars: this.hasNoConstrains(params) ? namesAllowedChars : void 0
+    };
+    return this.nameFormatter.mock(opts, rt, defaultParams);
+  }
+  mockTld(opts, rt, params) {
+    const hasParams = !!Object.keys(params).length;
+    if (!hasParams)
+      return randomItem(TLD_SAMPLES);
+    const defaultParams = {
+      ...params,
+      maxLength: params.maxLength ?? 12,
+      minLength: params.minLength ?? 2,
+      pattern: params.pattern,
+      allowedValues: params.allowedValues,
+      disallowedValues: params.disallowedValues,
+      allowedChars: this.hasNoConstrains(params) ? tldAllowedChars : void 0
+    };
+    return this.tldFormatter.mock(opts, rt, defaultParams);
+  }
+  emitFormat(comp) {
+    return { code: `${comp.vλl}.toLowerCase()`, type: "E" };
+  }
+  _formatMockedValue(opts, _rt, val) {
+    return val.toLowerCase();
+  }
+  validateParams(rt, params) {
+    const onlyOne = [params.names, params.pattern].filter(Boolean);
+    if (onlyOne.length > 1)
+      throw new Error(`Domain can only have one of (names & tld), pattern or allowedValues in type ${this.printPath(rt)}`);
+    if (params.maxLength && paramVal(params.maxLength) > 253)
+      throw new Error(`Domain maxLength cannot be greater than 253 in type ${this.printPath(rt, "maxLength")}`);
+    if (params.minLength && paramVal(params.minLength) < 3)
+      throw new Error(`Domain minLength cannot be less than 3 in type ${this.printPath(rt, "minLength")}`);
+    if (params.minParts && paramVal(params.minParts) < 2)
+      throw new Error(`Domain minParts cannot be less than 2 in type ${this.printPath(rt, "minParts")}`);
+    if (params.maxParts && paramVal(params.maxParts) < 2)
+      throw new Error(`Domain maxParts cannot be less than 2 in type ${this.printPath(rt, "maxParts")}`);
+    if (params.names && !params.tld || !params.names && params.tld)
+      throw new Error(`Domain names and tld must be used together in type ${this.printPath(rt, "maxParts")}`);
+    if (params.tld && params.tld.minLength && paramVal(params.tld.minLength) < 2)
+      throw new Error(`Domain tld.minLength cannot be less than 2 in type ${this.printPath(rt, "tld.minLength")}`);
+    if (params.tld && params.tld.maxLength && paramVal(params.tld.maxLength) > 63)
+      throw new Error(`Domain tld.maxLength cannot be greater than 63 in type ${this.printPath(rt, "tld.maxLength")}`);
+    if (params.names && params.names.maxLength && paramVal(params.names.maxLength) > 63)
+      throw new Error(`Domain names.maxLength cannot be greater than 63 in type ${this.printPath(rt, "names.maxLength")}`);
+    this.rootFormatter.validateParams(rt, params);
+    if (params.names?.allowedValues)
+      params.names?.allowedValues.val.forEach((val) => {
+        if (val.startsWith("-") || val.endsWith("-"))
+          throw new Error(`allowedValues[${val}] can not start or end with a hyphen in type ${this.printPath(rt, "names.allowedValues")}`);
+      });
+    if (params.names) {
+      if (Object.values(params.names).length === 0)
+        throw new Error(`Domain names must have at least one validator in type ${this.printPath(rt, "names")}`);
+      this.nameFormatter.validateParams(rt, params.names);
+    }
+    if (params.tld) {
+      if (Object.values(params.tld).length === 0)
+        throw new Error(`Domain tld must have at least one validator in type ${this.printPath(rt, "tld")}`);
+      this.tldFormatter.validateParams(rt, params.tld);
+    }
+  }
+}
+const DOMAIN_RUN_TYPE_FORMATTER = registerFormatter(new DomainRunTypeFormat());
+const __ΩDEFAULT_DOMAIN_PARAMS = [() => DOMAIN_PATTERN, "P", "ggle.com", "mion.io", "mionkit.io", "yahuu.net", "fbook.com", "wiki.org", "ms.net", "S", 253, "maxLength", 5, "minLength", "val", "mockSamples", "invalid domain", "errorMessage", "pattern", "DEFAULT_DOMAIN_PARAMS", `i!c"P.#.$.%.&.'.(.)Gc*P.+4,.-4.Pe#!4/e#"40.142M43Mw4y`];
+const __ΩDEFAULT_DMM_TLD_PARAMS = [() => TLD_ALLOWED_CHARS_PATTERN, "P", "com", "org", "net", "io", "app", "co", "dev", "tech", "ai", "mion", "co.uk", "com.au", "com.br", "S", 12, "maxLength", 2, "minLength", "val", "mockSamples", "top level domain can only contain letters and dots", "errorMessage", "pattern", "DEFAULT_DMM_TLD_PARAMS", `i!c"P.#.$.%.&.'.(.).*.+.,.-.../Gc0P.142.344Pe#!45e#"46.748M49Mw:y`];
+const __ΩDEFAULT_DOM_NAME_PARAMS = [() => DOMAIN_ALLOWED_CHARS_PATTERN, "P", "domain", "ggle", "fbook", "mion", "prot", "yahuu", "hello", "world", "example", "wiki", "mionkit", "S", 63, "maxLength", 2, "minLength", "val", "mockSamples", "domain names can only contain letters, numbers and hyphens", "errorMessage", "pattern", "DEFAULT_DOM_NAME_PARAMS", `i!c"P.#.$.%.&.'.(.).*.+.,.-Gc.P./40.142Pe#!43e#"44.546M47Mw8y`];
+const __ΩDEFAULT_STRICT_DOMAIN_PARAMS = [6, "maxParts", 2, "minParts", () => __ΩDEFAULT_DOM_NAME_PARAMS, "names", () => __ΩDEFAULT_DMM_TLD_PARAMS, "tld", 253, "maxLength", 5, "minLength", "DEFAULT_STRICT_DOMAIN_PARAMS", `P.!4".#4$n%4&n'4(.)4*.+4,Mw-y`];
+const __ΩFormatDomain = [() => __ΩDEFAULT_DOMAIN_PARAMS, "DP", () => ___TypeFormat, "domain", "domain", "FormatDomain", 'n!c"&.$e!!.%o#%w&y'];
+const __ΩFormatDomainStrict = ["D", () => __ΩFormatDomain, () => __ΩDEFAULT_STRICT_DOMAIN_PARAMS, "FormatDomainStrict", 'PMc!Pn#e"!Ko""w$y'];
+export {
+  DOMAIN_ALLOWED_CHARS_PATTERN,
+  DOMAIN_PATTERN,
+  DOMAIN_PATTERN_PUNYCODE,
+  DOMAIN_PATTERN_UNICODE,
+  DOMAIN_RUN_TYPE_FORMATTER,
+  DomainRunTypeFormat,
+  TLD_ALLOWED_CHARS_PATTERN,
+  __ΩDEFAULT_DMM_TLD_PARAMS,
+  __ΩDEFAULT_DOMAIN_PARAMS,
+  __ΩDEFAULT_DOM_NAME_PARAMS,
+  __ΩDEFAULT_STRICT_DOMAIN_PARAMS,
+  __ΩFormatDomain,
+  __ΩFormatDomainStrict
+};
+//# sourceMappingURL=domain.runtype.js.map

package/.dist/esm/src/string/domain.runtype.js.map

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

package/.dist/esm/src/string/email.runtype.d.ts

@@ -0,0 +1,57 @@
+import { BaseRunType, JitFnCompiler, JitErrorsFnCompiler, StrNumber, JitFnID, JitCode, BaseRunTypeFormat, TypeFormat, RunTypeOptions } from '@mionjs/run-types';
+import { ReflectionKind } from '@deepkit/type';
+import { DEFAULT_STRICT_DOMAIN_PARAMS } from './domain.runtype.ts';
+import { FormatParams_Email, Samples } from '@mionjs/core';
+import { EMAIL_NAME_SAMPLES, EMAIL_SAMPLES, EMAIL_SAMPLES_PUNYCODE } from '../constants.mock.ts';
+export declare const EMAIL_PATTERN: RegExp;
+export declare const EMAIL_PATTERN_PUNYCODE: RegExp;
+export declare class EmailRunTypeFormat extends BaseRunTypeFormat<FormatParams_Email> {
+    static id: string;
+    kind: ReflectionKind;
+    name: string;
+    private rootFormatter;
+    private domainFormatter;
+    private localPartFormatter;
+    constructor(parentPath?: StrNumber[]);
+    getIgnoredProps(): string[] | undefined;
+    canEmbedFormatterCode(fnID: JitFnID, rt: BaseRunType, p?: FormatParams_Email): boolean;
+    emitIsType(comp: JitFnCompiler, rt: BaseRunType): JitCode;
+    emitIsTypeErrors(comp: JitErrorsFnCompiler, rt: BaseRunType): JitCode;
+    _mock(opts: RunTypeOptions, rt: BaseRunType): string;
+    private mockLocalPart;
+    emitFormat(comp: JitFnCompiler): JitCode;
+    validateParams(rt: BaseRunType, params: FormatParams_Email): void;
+}
+export declare const EMAIL_RUN_TYPE_FORMATTER: EmailRunTypeFormat;
+export type DEFAULT_STRICT_EMAIL_PARAMS = {
+    maxLength: 254;
+    localPart: {
+        maxLength: 64;
+        minLength: 1;
+        disallowedChars: {
+            val: ` ()<>[]:;\\,{}|+@`;
+            errorMessage: 'Invalid characters in email local part';
+            mockSamples: EMAIL_NAME_SAMPLES;
+        };
+    };
+    domain: DEFAULT_STRICT_DOMAIN_PARAMS;
+};
+export type DEFAULT_EMAIL_PARAMS<EmailPattern extends RegExp = typeof EMAIL_PATTERN, MockSamples extends Samples = EMAIL_SAMPLES> = {
+    maxLength: 254;
+    minLength: 7;
+    pattern: {
+        val: EmailPattern;
+        mockSamples: MockSamples;
+        errorMessage: 'Invalid email format';
+    };
+};
+export type FormatEmail<EP extends FormatParams_Email = DEFAULT_EMAIL_PARAMS> = TypeFormat<string, 'email', EP, 'email'>;
+export type FormatEmailStrict<E extends Partial<FormatParams_Email> = {}> = FormatEmail<DEFAULT_STRICT_EMAIL_PARAMS & E>;
+export type FormatEmailPattern<EmailPattern extends RegExp, MockSamples extends Samples> = FormatEmail<DEFAULT_EMAIL_PARAMS<EmailPattern, MockSamples>>;
+export type FormatEmailPunycode = FormatEmailPattern<typeof EMAIL_PATTERN_PUNYCODE, EMAIL_SAMPLES_PUNYCODE>;
+export declare type __ΩDEFAULT_STRICT_EMAIL_PARAMS = any[];
+export declare type __ΩDEFAULT_EMAIL_PARAMS = any[];
+export declare type __ΩFormatEmail = any[];
+export declare type __ΩFormatEmailStrict = any[];
+export declare type __ΩFormatEmailPattern = any[];
+export declare type __ΩFormatEmailPunycode = any[];