@mionjs/type-formats 0.8.0-alpha.0

package/.dist/cjs/src/string/date.runtype.cjs

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const type = require("@deepkit/type");
+const runTypes = require("@mionjs/run-types");
+const src_utils = require("../utils.cjs");
+const src_typeFormatsPureFns = require("../type-formats-pure-fns.cjs");
+class DateStringRunTypeFormat extends runTypes.BaseRunTypeFormat {
+  static id = "date";
+  kind = type.ReflectionKind.string;
+  name = DateStringRunTypeFormat.id;
+  emitIsType(comp, rt) {
+    const params = this.getParams(rt);
+    const formatFn = this.getFormatPureFn(src_utils.paramVal(params.format));
+    return { code: this.compilePureFunctionCall(comp, rt, formatFn).callCode, type: "E" };
+  }
+  emitIsTypeErrors(comp, rt) {
+    const isTypeCodeObj = this.emitIsType(comp, rt);
+    const isTypeCode = isTypeCodeObj.code;
+    if (!isTypeCode)
+      return { code: "", type: "S" };
+    const params = this.getParams(rt);
+    const errFn = this.getCallJitFormatErr(comp, rt, this);
+    return { code: `if (!(${isTypeCode})) ${errFn("format", src_utils.paramVal(params.format))}`, type: "S" };
+  }
+  _mock(opts, rt) {
+    const params = this.getParams(rt);
+    const yy = Math.floor(Math.random() * 1e4);
+    const mm = Math.floor(Math.random() * 12) + 1;
+    const dd = Math.floor(Math.random() * getMaxDaysInMonth(yy, mm)) + 1;
+    const year = String(yy).padStart(4, "0");
+    const month = String(mm).padStart(2, "0");
+    const day = String(dd).padStart(2, "0");
+    switch (src_utils.paramVal(params.format)) {
+      case "ISO":
+      case "YYYY-MM-DD":
+        return `${year}-${month}-${day}`;
+      case "DD-MM-YYYY":
+        return `${day}-${month}-${year}`;
+      case "MM-DD-YYYY":
+        return `${month}-${day}-${year}`;
+      case "YYYY-MM":
+        return `${year}-${month}`;
+      case "MM-DD":
+        return `${month}-${day}`;
+      case "DD-MM":
+        return `${day}-${month}`;
+      default:
+        throw new Error(`Invalid date format: ${src_utils.paramVal(params.format)}`);
+    }
+  }
+  getFormatPureFn(format) {
+    switch (format) {
+      case "ISO":
+      case "YYYY-MM-DD":
+        return src_typeFormatsPureFns.cpf_isDateString_YMD;
+      case "DD-MM-YYYY":
+        return src_typeFormatsPureFns.cpf_isDateString_DMY;
+      case "MM-DD-YYYY":
+        return src_typeFormatsPureFns.cpf_isDateString_MDY;
+      case "YYYY-MM":
+        return src_typeFormatsPureFns.cpf_isDateString_YM;
+      case "MM-DD":
+        return src_typeFormatsPureFns.cpf_isDateString_MD;
+      case "DD-MM":
+        return src_typeFormatsPureFns.cpf_isDateString_DM;
+      default:
+        throw new Error(`Invalid date format: ${format}`);
+    }
+  }
+}
+function getMaxDaysInMonth(year, month) {
+  if (month === 2) {
+    if (year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0))
+      return 29;
+    return 28;
+  }
+  if (month === 4 || month === 6 || month === 9 || month === 11)
+    return 30;
+  return 31;
+}
+const DATE_RUN_TYPE_FORMATTER = runTypes.registerFormatter(new DateStringRunTypeFormat());
+const __ΩDEFAULT_DATE_PARAMS = ["ISO", "format", "DEFAULT_DATE_PARAMS", 'P.!4"Mw#y'];
+const __ΩFormatStringDate = [() => __ΩDEFAULT_DATE_PARAMS, "P", () => runTypes.__ΩTypeFormat, () => DateStringRunTypeFormat.id, "date", "FormatStringDate", 'n!c"&i$e!!.%o#%w&y'];
+exports.DATE_RUN_TYPE_FORMATTER = DATE_RUN_TYPE_FORMATTER;
+exports.DateStringRunTypeFormat = DateStringRunTypeFormat;
+exports.__ΩDEFAULT_DATE_PARAMS = __ΩDEFAULT_DATE_PARAMS;
+exports.__ΩFormatStringDate = __ΩFormatStringDate;
+//# sourceMappingURL=date.runtype.cjs.map

package/.dist/cjs/src/string/date.runtype.cjs.map

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

package/.dist/cjs/src/string/date.runtype.d.ts

@@ -0,0 +1,19 @@
+import { ReflectionKind } from '@deepkit/type';
+import { JitFnCompiler, JitErrorsFnCompiler, BaseRunType, RunTypeOptions, JitCode, BaseRunTypeFormat, TypeFormat } from '@mionjs/run-types';
+import { DateFmt, FormatParams_Date } from '@mionjs/core';
+export declare class DateStringRunTypeFormat extends BaseRunTypeFormat<FormatParams_Date> {
+    static id: "date";
+    kind: ReflectionKind;
+    name: "date";
+    emitIsType(comp: JitFnCompiler, rt: BaseRunType): JitCode;
+    emitIsTypeErrors(comp: JitErrorsFnCompiler, rt: BaseRunType): JitCode;
+    _mock(opts: RunTypeOptions, rt: BaseRunType): string;
+    getFormatPureFn(format: DateFmt): import('@mionjs/core').CompiledPureFunction;
+}
+export declare const DATE_RUN_TYPE_FORMATTER: DateStringRunTypeFormat;
+export type DEFAULT_DATE_PARAMS = {
+    format: 'ISO';
+};
+export type FormatStringDate<P extends Partial<FormatParams_Date> = DEFAULT_DATE_PARAMS> = TypeFormat<string, typeof DateStringRunTypeFormat.id, P, 'date'>;
+export declare type __ΩDEFAULT_DATE_PARAMS = any[];
+export declare type __ΩFormatStringDate = any[];

package/.dist/cjs/src/string/dateTime.runtype.cjs

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const runTypes = require("@mionjs/run-types");
+const type = require("@deepkit/type");
+const src_string_date_runtype = require("./date.runtype.cjs");
+const src_string_time_runtype = require("./time.runtype.cjs");
+const src_string_stringFormat_runtype = require("./stringFormat.runtype.cjs");
+const src_utils = require("../utils.cjs");
+class DateTimeRunTypeFormat extends runTypes.BaseRunTypeFormat {
+  static id = "dateTime";
+  kind = type.ReflectionKind.string;
+  name = DateTimeRunTypeFormat.id;
+  dateFormatter;
+  timeFormatter;
+  constructor(parentPath) {
+    super(parentPath);
+    this.dateFormatter = new src_string_date_runtype.DateStringRunTypeFormat(this.getFormatPath("date"));
+    this.timeFormatter = new src_string_time_runtype.TimeStringRunTypeFormat(this.getFormatPath("time"));
+  }
+  getIgnoredProps() {
+    return src_string_stringFormat_runtype.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 = src_utils.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 = src_utils.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 = src_utils.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 = runTypes.registerFormatter(new DateTimeRunTypeFormat());
+const __ΩDEFAULT_DATE_TIME_PARAMS = [() => src_string_date_runtype.__ΩDEFAULT_DATE_PARAMS, "date", () => src_string_time_runtype.__ΩDEFAULT_TIME_FORMAT_PARAMS, "time", "T", "splitChar", "DEFAULT_DATE_TIME_PARAMS", `Pn!4"n#4$.%4&Mw'y`];
+const __ΩFormatStringDateTime = ["P", () => runTypes.__ΩTypeFormat, () => DateTimeRunTypeFormat.id, () => __ΩDEFAULT_DATE_TIME_PARAMS, "dateTime", "FormatStringDateTime", 'PMc!&i#Pn$e"!K.%o"%w&y'];
+exports.DATE_TIME_RUN_TYPE_FORMATTER = DATE_TIME_RUN_TYPE_FORMATTER;
+exports.DateTimeRunTypeFormat = DateTimeRunTypeFormat;
+exports.__ΩDEFAULT_DATE_TIME_PARAMS = __ΩDEFAULT_DATE_TIME_PARAMS;
+exports.__ΩFormatStringDateTime = __ΩFormatStringDateTime;
+//# sourceMappingURL=dateTime.runtype.cjs.map

package/.dist/cjs/src/string/dateTime.runtype.cjs.map

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

package/.dist/cjs/src/string/dateTime.runtype.d.ts

@@ -0,0 +1,26 @@
+import { BaseRunType, JitFnCompiler, JitErrorsFnCompiler, JitCode, TypeFormat, RunTypeOptions, BaseRunTypeFormat } from '@mionjs/run-types';
+import { ReflectionKind } from '@deepkit/type';
+import { DEFAULT_DATE_PARAMS, DateStringRunTypeFormat } from './date.runtype.ts';
+import { FormatParams_DateTime } from '@mionjs/core';
+import { DEFAULT_TIME_FORMAT_PARAMS, TimeStringRunTypeFormat } from './time.runtype.ts';
+export declare class DateTimeRunTypeFormat extends BaseRunTypeFormat<FormatParams_DateTime> {
+    static id: "dateTime";
+    kind: ReflectionKind;
+    name: "dateTime";
+    dateFormatter: DateStringRunTypeFormat;
+    timeFormatter: TimeStringRunTypeFormat;
+    constructor(parentPath?: string[]);
+    getIgnoredProps(): string[] | undefined;
+    emitIsType(comp: JitFnCompiler, rt: BaseRunType): JitCode;
+    emitIsTypeErrors(comp: JitErrorsFnCompiler, rt: BaseRunType): JitCode;
+    _mock(opts: RunTypeOptions, rt: BaseRunType): string;
+}
+export declare const DATE_TIME_RUN_TYPE_FORMATTER: DateTimeRunTypeFormat;
+export type DEFAULT_DATE_TIME_PARAMS = {
+    date: DEFAULT_DATE_PARAMS;
+    time: DEFAULT_TIME_FORMAT_PARAMS;
+    splitChar: 'T';
+};
+export type FormatStringDateTime<P extends Partial<FormatParams_DateTime> = {}> = TypeFormat<string, typeof DateTimeRunTypeFormat.id, DEFAULT_DATE_TIME_PARAMS & P, 'dateTime'>;
+export declare type __ΩDEFAULT_DATE_TIME_PARAMS = any[];
+export declare type __ΩFormatStringDateTime = any[];

package/.dist/cjs/src/string/defaultStringFormats.runtype.cjs

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const src_string_stringFormat_runtype = require("./stringFormat.runtype.cjs");
+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", () => src_string_stringFormat_runtype.__ΩFormatString, () => __ΩDEFAULT_ALPHA_NUM_PARAMS, "FormatAlphaNumeric", 'PMc!Pe"!n#Ko""w$y'];
+const __ΩFormatAlpha = ["P", () => src_string_stringFormat_runtype.__ΩFormatString, () => __ΩDEFAULT_ALPHA_PARAMS, "FormatAlpha", 'PMc!Pe"!n#Ko""w$y'];
+const __ΩFormatNumeric = ["P", () => src_string_stringFormat_runtype.__ΩFormatString, () => __ΩDEFAULT_NUMERIC_PARAMS, "FormatNumeric", 'PMc!Pe"!n#Ko""w$y'];
+const __ΩFormatLowercase = ["P", () => src_string_stringFormat_runtype.__ΩFormatString, true, "lowercase", "FormatLowercase", 'PMc!Pe"!P.#4$MKo""w%y'];
+const __ΩFormatUppercase = ["P", () => src_string_stringFormat_runtype.__ΩFormatString, true, "uppercase", "FormatUppercase", 'PMc!Pe"!P.#4$MKo""w%y'];
+const __ΩFormatCapitalize = ["P", () => src_string_stringFormat_runtype.__ΩFormatString, true, "capitalize", "FormatCapitalize", 'PMc!Pe"!P.#4$MKo""w%y'];
+exports.ALPHANUMERIC_REGEX = ALPHANUMERIC_REGEX;
+exports.ALPHA_REGEX = ALPHA_REGEX;
+exports.NUMERIC_REGEX = NUMERIC_REGEX;
+exports.__ΩFormatAlpha = __ΩFormatAlpha;
+exports.__ΩFormatAlphaNumeric = __ΩFormatAlphaNumeric;
+exports.__ΩFormatCapitalize = __ΩFormatCapitalize;
+exports.__ΩFormatLowercase = __ΩFormatLowercase;
+exports.__ΩFormatNumeric = __ΩFormatNumeric;
+exports.__ΩFormatUppercase = __ΩFormatUppercase;
+//# sourceMappingURL=defaultStringFormats.runtype.cjs.map

package/.dist/cjs/src/string/defaultStringFormats.runtype.cjs.map

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

package/.dist/cjs/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/cjs/src/string/domain.runtype.cjs

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const runTypes = require("@mionjs/run-types");
+const type = require("@deepkit/type");
+const src_string_stringFormat_runtype = require("./stringFormat.runtype.cjs");
+const src_constants_mock = require("../constants.mock.cjs");
+const src_utils = require("../utils.cjs");
+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: src_constants_mock.TLD_CHARS,
+  errorMessage: "only alphabetical characters allowed"
+};
+const namesAllowedChars = {
+  val: src_constants_mock.NAME_CHARS,
+  errorMessage: "only alphabetical characters and hyphens allowed"
+};
+class DomainRunTypeFormat extends runTypes.BaseRunTypeFormat {
+  static id = "domain";
+  kind = type.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 src_string_stringFormat_runtype.StringRunTypeFormat(domainPath);
+    this.nameFormatter = new src_string_stringFormat_runtype.StringRunTypeFormat(namePath);
+    this.tldFormatter = new src_string_stringFormat_runtype.StringRunTypeFormat(tldPath);
+  }
+  canEmbedFormatterCode(fnID, rt, p) {
+    const params = p || this.getParams(rt);
+    if (fnID === runTypes.JitFunctions.isType.id || fnID === runTypes.JitFunctions.typeErrors.id)
+      return super.canEmbedFormatterCode(fnID, rt) && !!params.pattern;
+    return super.canEmbedFormatterCode(fnID, rt);
+  }
+  getIgnoredProps() {
+    return src_string_stringFormat_runtype.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", src_utils.paramVal(params.maxParts))};` : "";
+    const minPartsCode = params.minParts ? `if (${vCount} < ${params.minParts}) ${errFn("minParts", src_utils.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 = src_utils.paramVal(params.maxParts || 6);
+    const minParts = src_utils.paramVal(params.minParts || 2);
+    const maxLength = src_utils.paramVal(params.maxLength || 253);
+    const minLength = src_utils.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 - src_utils.paramVal(tldParts.length);
+    const maxRandomParts = runTypes.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 runTypes.randomItem(src_constants_mock.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 runTypes.randomItem(src_constants_mock.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 && src_utils.paramVal(params.maxLength) > 253)
+      throw new Error(`Domain maxLength cannot be greater than 253 in type ${this.printPath(rt, "maxLength")}`);
+    if (params.minLength && src_utils.paramVal(params.minLength) < 3)
+      throw new Error(`Domain minLength cannot be less than 3 in type ${this.printPath(rt, "minLength")}`);
+    if (params.minParts && src_utils.paramVal(params.minParts) < 2)
+      throw new Error(`Domain minParts cannot be less than 2 in type ${this.printPath(rt, "minParts")}`);
+    if (params.maxParts && src_utils.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 && src_utils.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 && src_utils.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 && src_utils.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 = runTypes.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", () => runTypes.__Ω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'];
+exports.DOMAIN_ALLOWED_CHARS_PATTERN = DOMAIN_ALLOWED_CHARS_PATTERN;
+exports.DOMAIN_PATTERN = DOMAIN_PATTERN;
+exports.DOMAIN_PATTERN_PUNYCODE = DOMAIN_PATTERN_PUNYCODE;
+exports.DOMAIN_PATTERN_UNICODE = DOMAIN_PATTERN_UNICODE;
+exports.DOMAIN_RUN_TYPE_FORMATTER = DOMAIN_RUN_TYPE_FORMATTER;
+exports.DomainRunTypeFormat = DomainRunTypeFormat;
+exports.TLD_ALLOWED_CHARS_PATTERN = TLD_ALLOWED_CHARS_PATTERN;
+exports.__ΩDEFAULT_DMM_TLD_PARAMS = __ΩDEFAULT_DMM_TLD_PARAMS;
+exports.__ΩDEFAULT_DOMAIN_PARAMS = __ΩDEFAULT_DOMAIN_PARAMS;
+exports.__ΩDEFAULT_DOM_NAME_PARAMS = __ΩDEFAULT_DOM_NAME_PARAMS;
+exports.__ΩDEFAULT_STRICT_DOMAIN_PARAMS = __ΩDEFAULT_STRICT_DOMAIN_PARAMS;
+exports.__ΩFormatDomain = __ΩFormatDomain;
+exports.__ΩFormatDomainStrict = __ΩFormatDomainStrict;
+//# sourceMappingURL=domain.runtype.cjs.map

package/.dist/cjs/src/string/domain.runtype.cjs.map

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

package/.dist/cjs/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[];