@mionjs/type-formats 0.8.0-alpha.0

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

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const runTypes = require("@mionjs/run-types");
+const type = require("@deepkit/type");
+const src_string_domain_runtype = require("./domain.runtype.cjs");
+const src_string_stringFormat_runtype = require("./stringFormat.runtype.cjs");
+const src_constants_mock = require("../constants.mock.cjs");
+const src_utils = require("../utils.cjs");
+const EMAIL_PATTERN = /^[^\s@]{1,64}@(?:[a-zA-Z0-9-]{1,63}\.)+[a-zA-Z]{2,63}$/;
+const EMAIL_PATTERN_PUNYCODE = /^[^\s@]{1,64}@(?:[a-zA-Z0-9-]{1,63}\.)+[a-zA-Z0-9-]{2,63}$/;
+class EmailRunTypeFormat extends runTypes.BaseRunTypeFormat {
+  static id = "email";
+  kind = type.ReflectionKind.string;
+  name = EmailRunTypeFormat.id;
+  // Formatter instances as class variables
+  rootFormatter;
+  domainFormatter;
+  localPartFormatter;
+  constructor(parentPath) {
+    super(parentPath);
+    this.rootFormatter = new src_string_stringFormat_runtype.StringRunTypeFormat(this.getFormatPath());
+    this.domainFormatter = new src_string_domain_runtype.DomainRunTypeFormat(this.getFormatPath("domain"));
+    this.localPartFormatter = new src_string_stringFormat_runtype.StringRunTypeFormat(this.getFormatPath("localPart"));
+  }
+  getIgnoredProps() {
+    return src_string_stringFormat_runtype.stringIgnoreProps;
+  }
+  canEmbedFormatterCode(fnID, rt, p) {
+    const params = p || this.getParams(rt);
+    if (fnID === runTypes.JitFunctions.isType.id || fnID === runTypes.JitFunctions.typeErrors.id) {
+      const superResult = super.canEmbedFormatterCode(fnID, rt);
+      const domainResult = params.domain ? this.domainFormatter.canEmbedFormatterCode(fnID, rt, params.domain) : false;
+      return superResult && (!!params.pattern || domainResult);
+    }
+    return super.canEmbedFormatterCode(fnID, rt);
+  }
+  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 vLocalPart = "localPart" + this.getFormatNestLevel();
+    const vDomain = "domain" + this.getFormatNestLevel();
+    const vAtPos = "atPos" + this.getFormatNestLevel();
+    const rootCode = this.rootFormatter.compileFormat(fnID, comp, rt, params, vλl, fmtName);
+    const localPartCode = this.localPartFormatter.compileFormat(fnID, comp, rt, params.localPart, vLocalPart, fmtName);
+    const domainCode = this.domainFormatter.compileFormat(fnID, comp, rt, params.domain, vDomain, fmtName);
+    const rootSafeCode = rootCode.code ? `if (!(${rootCode.code})) return false;` : "";
+    const returnCode = this.isRootFormat() ? `return true;` : "";
+    const domainIsExpression = domainCode.type === "E";
+    const domainSafeCode = domainCode.code && domainIsExpression ? `if (!(${domainCode.code})) return false;` : domainCode.code;
+    const code = `
+            ${rootSafeCode}
+            const ${vAtPos} = ${vλl}.lastIndexOf('@');
+            if (${vAtPos} === -1) return false;
+            const ${vLocalPart} = ${vλl}.substring(0, ${vAtPos});
+            const ${vDomain} = ${vλl}.substring(${vAtPos} + 1);
+            if (!(${localPartCode.code})) return false;
+            ${domainSafeCode}
+            ${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 vLocalPart = "localPart";
+    const vDomain = "domain";
+    const vAtPos = "atPos";
+    const rootCode = this.rootFormatter.compileFormat(fnID, comp, rt, params, vλl, fmtName);
+    const localPartCode = this.localPartFormatter.compileFormat(fnID, comp, rt, params.localPart, vLocalPart, fmtName);
+    const domainCode = this.domainFormatter.compileFormat(fnID, comp, rt, params.domain, vDomain, fmtName);
+    const code = `
+            ${rootCode.code ? `${rootCode.code};` : ""}
+            const ${vAtPos} = ${vλl}.lastIndexOf('@');
+            if (${vAtPos} === -1) ${errFn("@", "Email missing @ symbol")};
+            const ${vLocalPart} = ${vλl}.substring(0, ${vAtPos});
+            const ${vDomain} = ${vλl}.substring(${vAtPos} + 1);
+            ${localPartCode.code ? `${localPartCode.code};` : ""}
+            ${domainCode.code ? `${domainCode.code};` : ""}
+        `;
+    return { code, type: "S" };
+  }
+  _mock(opts, rt) {
+    const params = this.getParams(rt);
+    if (params.pattern)
+      return this.rootFormatter.mock(opts, rt, params);
+    const localPart = this.mockLocalPart(opts, rt, params.localPart);
+    const domain = this.domainFormatter.mock(opts, rt, params.domain);
+    return `${localPart}@${domain}`;
+  }
+  mockLocalPart(opts, rt, params) {
+    const hasParams = !!Object.keys(params).length;
+    if (!hasParams)
+      return runTypes.randomItem(src_constants_mock.EMAIL_NAME_SAMPLES_ARRAY);
+    const defaultParams = {
+      ...params,
+      maxLength: params.maxLength ?? 64,
+      minLength: params.minLength ?? 1
+    };
+    return this.localPartFormatter.mock(opts, rt, defaultParams);
+  }
+  emitFormat(comp) {
+    return { code: `${comp.vλl}.toLowerCase()`, type: "E" };
+  }
+  validateParams(rt, params) {
+    const hasPattern = !!params.pattern;
+    const hasLocalPartOrDomain = !!params.localPart || !!params.domain;
+    if (hasPattern && hasLocalPartOrDomain)
+      throw new Error(`Email can only have either pattern or (localPart and domain) in type ${this.printPath(rt)}`);
+    if (params.localPart && !params.domain || !params.localPart && params.domain)
+      throw new Error(`Email localPart and domain must be used together in type ${this.printPath(rt)}`);
+    if (params.maxLength && src_utils.paramVal(params.maxLength) > 254)
+      throw new Error(`Email maxLength cannot be greater than 254 in type ${this.printPath(rt, "maxLength")}`);
+    if (params.minLength && src_utils.paramVal(params.minLength) < 7)
+      throw new Error(`Email minLength cannot be less than 7 in type ${this.printPath(rt, "minLength")}`);
+    this.rootFormatter.validateParams(rt, params);
+    if (params.localPart) {
+      if (Object.values(params.localPart).length === 0)
+        throw new Error(`Email localPart must have at least one validator in type ${this.printPath(rt, "localPart")}`);
+      if (params.localPart.maxLength && src_utils.paramVal(params.localPart.maxLength) > 64)
+        throw new Error(`Email localPart.maxLength cannot be greater than 64 in type ${this.printPath(rt, "localPart.maxLength")}`);
+      if (params.localPart.minLength && src_utils.paramVal(params.localPart.minLength) < 1)
+        throw new Error(`Email localPart.minLength cannot be less than 1 in type ${this.printPath(rt, "localPart.minLength")}`);
+      this.localPartFormatter.validateParams(rt, params.localPart);
+    }
+    if (params.domain) {
+      if (Object.values(params.domain).length === 0) {
+        throw new Error(`Email domain must have at least one validator in type ${this.printPath(rt, "domain")}`);
+      }
+      this.domainFormatter.validateParams(rt, params.domain);
+    }
+  }
+}
+const EMAIL_RUN_TYPE_FORMATTER = runTypes.registerFormatter(new EmailRunTypeFormat());
+const __ΩDEFAULT_STRICT_EMAIL_PARAMS = [254, "maxLength", 64, 1, "minLength", ` ()<>[]:;\\,{}|+@`, "val", "Invalid characters in email local part", "errorMessage", () => src_constants_mock.__ΩEMAIL_NAME_SAMPLES, "mockSamples", "disallowedChars", "localPart", () => src_string_domain_runtype.__ΩDEFAULT_STRICT_DOMAIN_PARAMS, "domain", "DEFAULT_STRICT_EMAIL_PARAMS", `P.!4"P.#4".$4%P.&4'.(4)n*4+M4,M4-n.4/Mw0y`];
+const __ΩDEFAULT_EMAIL_PARAMS = [() => EMAIL_PATTERN, "EmailPattern", () => src_constants_mock.__ΩEMAIL_SAMPLES, "MockSamples", 254, "maxLength", 7, "minLength", "val", "mockSamples", "Invalid email format", "errorMessage", "pattern", "DEFAULT_EMAIL_PARAMS", `i!c"n#c$P.%4&.'4(Pe#!4)e#"4*.+4,M4-Mw.y`];
+const __ΩFormatEmail = [() => __ΩDEFAULT_EMAIL_PARAMS, "EP", () => runTypes.__ΩTypeFormat, "email", "email", "FormatEmail", 'n!c"&.$e!!.%o#%w&y'];
+const __ΩFormatEmailStrict = ["E", () => __ΩFormatEmail, () => __ΩDEFAULT_STRICT_EMAIL_PARAMS, "FormatEmailStrict", 'PMc!Pn#e"!Ko""w$y'];
+const __ΩFormatEmailPattern = ["EmailPattern", "MockSamples", () => __ΩFormatEmail, () => __ΩDEFAULT_EMAIL_PARAMS, "FormatEmailPattern", 'b!b"e!!e!"o$#o#"w%y'];
+const __ΩFormatEmailPunycode = [() => __ΩFormatEmailPattern, () => EMAIL_PATTERN_PUNYCODE, () => src_constants_mock.__ΩEMAIL_SAMPLES_PUNYCODE, "FormatEmailPunycode", 'i"n#o!#w$y'];
+exports.EMAIL_PATTERN = EMAIL_PATTERN;
+exports.EMAIL_PATTERN_PUNYCODE = EMAIL_PATTERN_PUNYCODE;
+exports.EMAIL_RUN_TYPE_FORMATTER = EMAIL_RUN_TYPE_FORMATTER;
+exports.EmailRunTypeFormat = EmailRunTypeFormat;
+exports.__ΩDEFAULT_EMAIL_PARAMS = __ΩDEFAULT_EMAIL_PARAMS;
+exports.__ΩDEFAULT_STRICT_EMAIL_PARAMS = __ΩDEFAULT_STRICT_EMAIL_PARAMS;
+exports.__ΩFormatEmail = __ΩFormatEmail;
+exports.__ΩFormatEmailPattern = __ΩFormatEmailPattern;
+exports.__ΩFormatEmailPunycode = __ΩFormatEmailPunycode;
+exports.__ΩFormatEmailStrict = __ΩFormatEmailStrict;
+//# sourceMappingURL=email.runtype.cjs.map

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

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

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

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const runTypes = require("@mionjs/run-types");
+const type = require("@deepkit/type");
+const src_utils = require("../utils.cjs");
+const src_typeFormatsPureFns = require("../type-formats-pure-fns.cjs");
+class IPRunTypeFormat extends runTypes.BaseRunTypeFormat {
+  static id = "ip";
+  kind = type.ReflectionKind.string;
+  name = IPRunTypeFormat.id;
+  emitIsType(comp, rt) {
+    const params = this.getParams(rt);
+    if (params.version === 4)
+      return { code: this.compilePureFunctionCall(comp, rt, src_typeFormatsPureFns.cpf_isIPV4).callCode, type: "E" };
+    if (params.version === 6)
+      return { code: this.compilePureFunctionCall(comp, rt, src_typeFormatsPureFns.cpf_isIPV6).callCode, type: "E" };
+    return {
+      code: `${this.compilePureFunctionCall(comp, rt, src_typeFormatsPureFns.cpf_isIPV4).callCode} || ${this.compilePureFunctionCall(comp, rt, src_typeFormatsPureFns.cpf_isIPV6).callCode}`,
+      type: "E"
+    };
+  }
+  _mock(opts, rt) {
+    const params = this.getParams(rt);
+    if (params.version === 4)
+      return mockIpV4(params);
+    if (params.version === 6)
+      return mockIpV6(params);
+    return Math.random() > 0.5 ? mockIpV4(params) : mockIpV6(params);
+  }
+  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("version", src_utils.paramVal(params.version))}`, type: "S" };
+  }
+  emitFormat(comp) {
+    return { code: `${comp.vλl}.toLowerCase()`, type: "E" };
+  }
+}
+function mockIpV4(p) {
+  const r = Math.random();
+  if (p.allowLocalHost && r > 0.8)
+    return Math.random() > 0.5 ? "localhost" : "127:0:0:1";
+  return Array.from({ length: 4 }, () => Math.floor(Math.random() * 256)).join(".");
+}
+function mockIpV6(p) {
+  if (p.allowLocalHost && Math.random() > 0.8)
+    return Math.random() > 0.5 ? "0:0:0:0:0:0:0:1" : "::1";
+  return Array.from({ length: 8 }, () => Math.floor(Math.random() * 65535).toString(16)).join(":");
+}
+const IP_RUN_TYPE_FORMATTER = runTypes.registerFormatter(new IPRunTypeFormat());
+const __ΩDEFAULT_IP_PARAMS = ["any", "version", true, "allowLocalHost", "DEFAULT_IP_PARAMS", 'P.!4".#4$Mw%y'];
+const __ΩFormatIP = [() => __ΩDEFAULT_IP_PARAMS, "P", () => runTypes.__ΩTypeFormat, "ip", "ip", "FormatIP", 'n!c"&.$e!!.%o#%w&y'];
+const __ΩFormatIPv4 = [() => __ΩFormatIP, 4, "version", true, "allowLocalHost", "FormatIPv4", 'P."4#.$4%Mo!"w&y'];
+const __ΩFormatIPv6 = [() => __ΩFormatIP, 6, "version", true, "allowLocalHost", "FormatIPv6", 'P."4#.$4%Mo!"w&y'];
+const __ΩFormatIPWithPort = [() => __ΩFormatIP, "any", "version", true, "allowLocalHost", true, "allowPort", "FormatIPWithPort", `P."4#.$4%.&4'Mo!"w(y`];
+const __ΩFormatIPv4WithPort = [() => __ΩFormatIP, 4, "version", true, "allowLocalHost", true, "allowPort", "FormatIPv4WithPort", `P."4#.$4%.&4'Mo!"w(y`];
+const __ΩFormatIPv6WithPort = [() => __ΩFormatIP, 6, "version", true, "allowLocalHost", true, "allowPort", "FormatIPv6WithPort", `P."4#.$4%.&4'Mo!"w(y`];
+exports.IPRunTypeFormat = IPRunTypeFormat;
+exports.IP_RUN_TYPE_FORMATTER = IP_RUN_TYPE_FORMATTER;
+exports.__ΩFormatIP = __ΩFormatIP;
+exports.__ΩFormatIPWithPort = __ΩFormatIPWithPort;
+exports.__ΩFormatIPv4 = __ΩFormatIPv4;
+exports.__ΩFormatIPv4WithPort = __ΩFormatIPv4WithPort;
+exports.__ΩFormatIPv6 = __ΩFormatIPv6;
+exports.__ΩFormatIPv6WithPort = __ΩFormatIPv6WithPort;
+exports.mockIpV4 = mockIpV4;
+exports.mockIpV6 = mockIpV6;
+//# sourceMappingURL=ip.runtype.cjs.map

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

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

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

@@ -0,0 +1,50 @@
+import { BaseRunType, JitFnCompiler, JitErrorsFnCompiler, RunTypeOptions, JitCode, BaseRunTypeFormat, TypeFormat } from '@mionjs/run-types';
+import { ReflectionKind } from '@deepkit/type';
+import { FormatParams_IP } from '@mionjs/core';
+export declare class IPRunTypeFormat extends BaseRunTypeFormat<FormatParams_IP> {
+    static id: string;
+    kind: ReflectionKind;
+    name: string;
+    emitIsType(comp: JitFnCompiler, rt: BaseRunType): JitCode;
+    _mock(opts: RunTypeOptions, rt: BaseRunType): string;
+    emitIsTypeErrors(comp: JitErrorsFnCompiler, rt: BaseRunType): JitCode;
+    emitFormat(comp: JitFnCompiler): JitCode;
+}
+export declare function mockIpV4(p: FormatParams_IP): string;
+export declare function mockIpV6(p: FormatParams_IP): string;
+export declare const IP_RUN_TYPE_FORMATTER: IPRunTypeFormat;
+type DEFAULT_IP_PARAMS = {
+    version: 'any';
+    allowLocalHost: true;
+};
+export type FormatIP<P extends FormatParams_IP = DEFAULT_IP_PARAMS> = TypeFormat<string, 'ip', P, 'ip'>;
+export type FormatIPv4 = FormatIP<{
+    version: 4;
+    allowLocalHost: true;
+}>;
+export type FormatIPv6 = FormatIP<{
+    version: 6;
+    allowLocalHost: true;
+}>;
+export type FormatIPWithPort = FormatIP<{
+    version: 'any';
+    allowLocalHost: true;
+    allowPort: true;
+}>;
+export type FormatIPv4WithPort = FormatIP<{
+    version: 4;
+    allowLocalHost: true;
+    allowPort: true;
+}>;
+export type FormatIPv6WithPort = FormatIP<{
+    version: 6;
+    allowLocalHost: true;
+    allowPort: true;
+}>;
+export {};
+export declare type __ΩFormatIP = any[];
+export declare type __ΩFormatIPv4 = any[];
+export declare type __ΩFormatIPv6 = any[];
+export declare type __ΩFormatIPWithPort = any[];
+export declare type __ΩFormatIPv4WithPort = any[];
+export declare type __ΩFormatIPv6WithPort = any[];

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

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const runTypes = require("@mionjs/run-types");
+const type = require("@deepkit/type");
+const src_utils = require("../utils.cjs");
+const defaultMessages = {
+  allowedChars: "Invalid characters",
+  disallowedChars: "Invalid characters",
+  allowedValues: "Invalid value",
+  disallowedValues: "Invalid value",
+  pattern: "Invalid pattern"
+};
+const propsWithRequiredSamples = ["disallowedChars", "disallowedChars", "pattern"];
+const stringIgnoreProps = ["samples", "sampleChars"];
+class StringRunTypeFormat extends runTypes.BaseRunTypeFormat {
+  static id = "stringFormat";
+  kind = type.ReflectionKind.string;
+  name = StringRunTypeFormat.id;
+  getIgnoredProps() {
+    return stringIgnoreProps;
+  }
+  emitFormat(comp, rt) {
+    const operations = [];
+    const p = this.getParams(rt);
+    const vλl = comp.vλl;
+    if (p.trim)
+      operations.push((v) => `${v}.trim()`);
+    if (p.replace)
+      operations.push((v) => `${v}.replace(${p?.replace?.searchValue}, ${p?.replace?.replaceValue})`);
+    if (p.replaceAll)
+      operations.push((v) => `${v}.replaceAll(${p?.replaceAll?.searchValue}, ${p?.replaceAll?.replaceValue})`);
+    if (p.lowercase)
+      operations.push((v) => `${v}.toLowerCase()`);
+    if (p.uppercase)
+      operations.push((v) => `${v}.toUpperCase()`);
+    if (p.capitalize)
+      operations.push((v) => `(${v}.charAt(0).toUpperCase() + ${vλl}.slice(1))`);
+    return { code: operations.reduce((acc, op) => op(acc), vλl), type: "E" };
+  }
+  emitIsType(comp, rt) {
+    const conditions = [];
+    const p = this.getParams(rt);
+    const vλl = comp.vλl;
+    const literalFn = runTypes.getToLiteralFn(comp, this.getIgnoredProps());
+    if (p.maxLength !== void 0)
+      conditions.push(`${vλl}.length <= ${literalFn(p.maxLength)}`);
+    if (p.minLength !== void 0)
+      conditions.push(`${vλl}.length >= ${literalFn(p.minLength)}`);
+    if (p.length !== void 0)
+      conditions.push(`${vλl}.length === ${literalFn(p.length)}`);
+    if (p.pattern !== void 0)
+      conditions.push(`${literalFn(p.pattern.val)}.test(${vλl})`);
+    if (p.allowedChars) {
+      const regexp = getAllowedCharsRegexp(p.allowedChars.val, p.allowedChars.ignoreCase);
+      conditions.push(`${literalFn(regexp)}.test(${vλl})`);
+    }
+    if (p.disallowedChars) {
+      const regexp = getDisallowedCharsRegexp(p.disallowedChars.val, p.disallowedChars.ignoreCase);
+      conditions.push(`!${literalFn(regexp)}.test(${vλl})`);
+    }
+    if (p.allowedValues) {
+      const regexp = getAllowedValuesRegexp(p.allowedValues.val, p.allowedValues.ignoreCase);
+      conditions.push(`${literalFn(regexp)}.test(${vλl})`);
+    }
+    if (p.disallowedValues) {
+      const regexp = getDisallowedValuesRegexp(p.disallowedValues.val, p.disallowedValues.ignoreCase);
+      conditions.push(`!${literalFn(regexp)}.test(${vλl})`);
+    }
+    return { code: conditions.join(" && "), type: "E" };
+  }
+  emitIsTypeErrors(comp, rt) {
+    const conditions = [];
+    const p = this.getParams(rt);
+    const vλl = comp.vλl;
+    const literalFn = runTypes.getToLiteralFn(comp, this.getIgnoredProps());
+    const errFn = this.getCallJitFormatErr(comp, rt, this, false);
+    if (p.maxLength !== void 0) {
+      const maxL = src_utils.paramVal(p.maxLength);
+      const errCode = errFn("maxLength", maxL);
+      conditions.push(`if (${vλl}.length > ${maxL}) ${errCode}`);
+    }
+    if (p.minLength !== void 0) {
+      const minL = src_utils.paramVal(p.minLength);
+      const errCode = errFn("minLength", minL);
+      conditions.push(`if (${vλl}.length < ${minL}) ${errCode}`);
+    }
+    if (p.length !== void 0) {
+      const length = src_utils.paramVal(p.length);
+      const errCode = errFn("length", length);
+      conditions.push(`if (${vλl}.length !== ${length}) ${errCode}`);
+    }
+    if (p.pattern !== void 0) {
+      const errCode = errFn("pattern", getDefaultMessage("pattern", p));
+      conditions.push(`if (!${literalFn(p.pattern.val)}.test(${vλl})) ${errCode}`);
+    }
+    if (p.allowedChars) {
+      const regexp = getAllowedCharsRegexp(p.allowedChars.val, p.allowedChars.ignoreCase);
+      const errCode = errFn("allowedChars", getDefaultMessage("allowedChars", p));
+      conditions.push(`if (!${literalFn(regexp)}.test(${vλl})) ${errCode}`);
+    }
+    if (p.disallowedChars) {
+      const regexp = getDisallowedCharsRegexp(p.disallowedChars.val, p.disallowedChars.ignoreCase);
+      const errCode = errFn("disallowedChars", getDefaultMessage("disallowedChars", p));
+      conditions.push(`if (${literalFn(regexp)}.test(${vλl})) ${errCode}`);
+    }
+    if (p.allowedValues) {
+      const regexp = getAllowedValuesRegexp(p.allowedValues.val, p.allowedValues.ignoreCase);
+      const errCode = errFn("allowedValues", getDefaultMessage("allowedValues", p));
+      conditions.push(`if (!${literalFn(regexp)}.test(${vλl})) ${errCode}`);
+    }
+    if (p.disallowedValues) {
+      const regexp = getDisallowedValuesRegexp(p.disallowedValues.val, p.disallowedValues.ignoreCase);
+      const errCode = errFn("disallowedValues", getDefaultMessage("disallowedValues", p));
+      conditions.push(`if (${literalFn(regexp)}.test(${vλl})) ${errCode}`);
+    }
+    return { code: conditions.join(";"), type: "S" };
+  }
+  _mock(opts, rt, params) {
+    const p = params || this.getParams(rt);
+    if (p.allowedValues)
+      return runTypes.randomItem(p.allowedValues.val);
+    const samples = p.pattern?.mockSamples || p.disallowedChars?.mockSamples || p.disallowedValues?.mockSamples;
+    if (samples && typeof samples !== "string" && Array.isArray(samples)) {
+      const ignoreCase = p.disallowedChars?.ignoreCase || p.disallowedValues?.ignoreCase;
+      const samplesAllCases = ignoreCase ? valuesAllCases(samples) : samples;
+      return runTypes.randomItem(samplesAllCases);
+    }
+    if (samples && typeof samples === "string") {
+      return this.mockString(p, samples, void 0);
+    }
+    const allowedChars = p.allowedChars?.ignoreCase ? charsAllCases(p.allowedChars.val) : p.allowedChars?.val;
+    const disallowedChars = p.disallowedChars?.ignoreCase ? charsAllCases(p.disallowedChars.val) : p.disallowedChars?.val;
+    return this.mockString(p, allowedChars, disallowedChars);
+  }
+  mockString(p, allowedChars, disallowedChars) {
+    switch (true) {
+      case p.length !== void 0:
+        return runTypes.mockString(src_utils.paramVal(p.length), allowedChars, disallowedChars);
+      case (p.maxLength !== void 0 && p.minLength !== void 0):
+        return runTypes.mockString(runTypes.random(src_utils.paramVal(p.minLength), src_utils.paramVal(p.maxLength)), allowedChars, disallowedChars);
+      case p.maxLength !== void 0:
+        return runTypes.mockString(runTypes.random(0, src_utils.paramVal(p.maxLength)), allowedChars, disallowedChars);
+      case p.minLength !== void 0: {
+        const minLength = src_utils.paramVal(p.minLength);
+        return runTypes.mockString(runTypes.random(minLength, minLength + runTypes.random(1, 1 + minLength * 2)), allowedChars, disallowedChars);
+      }
+      default:
+        return runTypes.mockString(void 0, allowedChars, disallowedChars);
+    }
+  }
+  validateParams(rt, p) {
+    const throwIfInvalid = (v, name, subName, skipLengthChecks = false) => {
+      const err = getParamError(v, p, skipLengthChecks);
+      if (err)
+        throw new Error(`Parameter ${name}.${subName} "${v}" does not satisfies "${err}" in type ${this.printPath(rt, subName)}`);
+    };
+    if (p.length !== void 0 && (p.maxLength !== void 0 || p.minLength !== void 0))
+      throw new Error(`length can not be used with maxLength or minLength in ${this.printPath(rt, "length")}`);
+    if (p.maxLength !== void 0 && p.minLength !== void 0 && p.maxLength < p.minLength)
+      throw new Error(`maxLength can not be less than minLength in ${this.printPath(rt, "maxLength")}`);
+    if (p.allowedValues?.val && p.allowedValues?.val.length > 100)
+      throw new Error(`allowedValues can not have more than 100 values in ${this.printPath(rt, "allowedValues")}`);
+    if (p.disallowedValues?.val && p.disallowedValues?.val.length > 100)
+      throw new Error(`disallowedValues can not have more than 100 values in ${this.printPath(rt, "disallowedValues")}`);
+    const complexParams = [
+      { name: "pattern", param: p.pattern },
+      { name: "allowedChars", param: p.allowedChars },
+      { name: "disallowedChars", param: p.disallowedChars },
+      { name: "allowedValues", param: p.allowedValues },
+      { name: "disallowedValues", param: p.disallowedValues }
+    ].filter((p2) => p2.param !== void 0);
+    if (complexParams.length > 1) {
+      throw new Error(`Only one of the parameters [pattern, allowedChars, disallowedChars, allowedValues, disallowedValues] can be used at once in ${this.printPath(rt)}`);
+    }
+    complexParams.forEach((c) => {
+      const { mockSamples } = c.param;
+      const requireSamples = propsWithRequiredSamples.includes(c.name);
+      if (requireSamples && !mockSamples)
+        throw new Error(`When ${c.name} is defined it is also required to provide samples in ${this.printPath(rt, c.name)}`);
+      if (Array.isArray(mockSamples) && mockSamples.length === 0)
+        throw new Error(`${c.name}.mockSamples can not be an empty array in ${this.printPath(rt, "mockSamples")}`);
+      if (typeof mockSamples === "string" && mockSamples.length === 0)
+        throw new Error(`${c.name}.mockSamples can not be an empty string in ${this.printPath(rt, "mockSamples")}`);
+      if (Array.isArray(mockSamples))
+        mockSamples.forEach((sample) => throwIfInvalid(sample, c.name, "mockSamples"));
+      if (typeof mockSamples === "string")
+        mockSamples.split("").forEach((char) => throwIfInvalid(char, c.name, "mockSamples", true));
+    });
+    if (p.allowedChars?.val)
+      throwIfInvalid(p.allowedChars?.val, "allowedChars", "val", true);
+    p.allowedValues?.val.forEach((v) => throwIfInvalid(v, "allowedValues", "val"));
+    if (p.pattern && p.replace && !p.pattern.val.test(p.replace.searchValue))
+      throw new Error(`replace.searchValue "${p.replace.searchValue}" invalid for pattern ${p.pattern.val} in ${this.printPath(rt, "replace")}`);
+    if (p.pattern && p.replaceAll && !p.pattern.val.test(p.replaceAll.searchValue))
+      throw new Error(`replaceAll.searchValue "${p.replaceAll.searchValue}" invalid for pattern ${p.pattern.val} in ${this.printPath(rt, "replaceAll")}`);
+    if ([p.lowercase, p.uppercase, p.capitalize].filter(Boolean).length > 1) {
+      throw new Error(`Only one text formatter (lowercase, uppercase, capitalize) allowed for ${this.printPath(rt, "formatters")}`);
+    }
+  }
+}
+function isPatternParam(p) {
+  const isMessage = p.message === void 0 || typeof p.message === "string";
+  const isSamples = p.samples === void 0 || Array.isArray(p.samples) && p.samples.every((s) => typeof s === "string");
+  const isSampleChars = p.sampleChars === void 0 || typeof p.sampleChars === "string" && p.sampleChars.length > 0;
+  const hasSamples = !!p.samples?.length || !!p.sampleChars?.length;
+  const isRegexpObj = typeof p.regexp === "object" && p.regexp instanceof RegExp;
+  return isMessage && hasSamples && isSamples && isSampleChars && isRegexpObj;
+}
+function patternParamsToStrParams(p) {
+  return { pattern: p };
+}
+function getParamError(v, p, skipLengthChecks = false) {
+  if (!skipLengthChecks) {
+    if (p.maxLength !== void 0 && v.length > p.maxLength)
+      return "maxLength";
+    if (p.minLength !== void 0 && v.length < p.minLength)
+      return "minLength";
+    if (p.length !== void 0 && v.length !== p.length)
+      return "length";
+  }
+  if (p.pattern && !p.pattern.val.test(v))
+    return "pattern";
+  if (p.allowedChars && !getAllowedCharsRegexp(p.allowedChars.val).test(v))
+    return "allowedChars";
+  if (p.disallowedChars && getDisallowedCharsRegexp(p.disallowedChars.val).test(v))
+    return "disallowedChars";
+  if (p.allowedValues && !p.allowedValues.val.includes(v))
+    return "allowedValues";
+  if (p.disallowedValues && p.disallowedValues.val.includes(v))
+    return "disallowedValues";
+}
+function getDefaultMessage(name, p) {
+  return p[name]?.errorMessage || defaultMessages[name];
+}
+function getAllowedCharsRegexp(allowedChars, ignoreCase) {
+  const flags = ignoreCase ? "i" : "";
+  return new RegExp(`^[${src_utils.regexpEscape(allowedChars)}]+$`, flags);
+}
+function getDisallowedCharsRegexp(disallowedChars, ignoreCase) {
+  const flags = ignoreCase ? "i" : "";
+  return new RegExp(`[${src_utils.regexpEscape(disallowedChars)}]`, flags);
+}
+function getAllowedValuesRegexp(allowedValues, ignoreCase) {
+  const flags = ignoreCase ? "i" : "";
+  return new RegExp(`^(?:${allowedValues.map((v) => src_utils.regexpEscape(v)).join("|")})$`, flags);
+}
+function getDisallowedValuesRegexp(disallowedValues, ignoreCase) {
+  const flags = ignoreCase ? "i" : "";
+  return new RegExp(`^(?:${disallowedValues.map((v) => src_utils.regexpEscape(v)).join("|")})$`, flags);
+}
+function charsAllCases(string) {
+  if (!string)
+    return;
+  const chars = string.split("");
+  const allCases = [...chars.map((c) => c.toLowerCase()), ...chars.map((c) => c.toUpperCase())];
+  return Array.from(new Set(allCases)).join("");
+}
+function valuesAllCases(stringList) {
+  const allCases = [...stringList, ...stringList.map((s) => s.toLowerCase()), ...stringList.map((s) => s.toUpperCase())];
+  return Array.from(new Set(allCases));
+}
+const STRING_RUN_TYPE_FORMATTER = runTypes.registerFormatter(new StringRunTypeFormat());
+const __ΩFormatString = ["P", "BrandName", () => runTypes.__ΩTypeFormat, () => StringRunTypeFormat.id, "FormatString", 'PMc!!c"&i$e!!e!"o#%w%y'];
+exports.STRING_RUN_TYPE_FORMATTER = STRING_RUN_TYPE_FORMATTER;
+exports.StringRunTypeFormat = StringRunTypeFormat;
+exports.__ΩFormatString = __ΩFormatString;
+exports.isPatternParam = isPatternParam;
+exports.patternParamsToStrParams = patternParamsToStrParams;
+exports.stringIgnoreProps = stringIgnoreProps;
+//# sourceMappingURL=stringFormat.runtype.cjs.map

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

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

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

@@ -0,0 +1,21 @@
+import { BaseRunType, JitFnCompiler, JitErrorsFnCompiler, JitCode, TypeFormat, BaseRunTypeFormat, RunTypeOptions } from '@mionjs/run-types';
+import { ReflectionKind } from '@deepkit/type';
+import { FormatParam_Pattern, StringParams } from '@mionjs/core';
+export declare const stringIgnoreProps: string[];
+export declare class StringRunTypeFormat extends BaseRunTypeFormat<StringParams> {
+    static readonly id: "stringFormat";
+    readonly kind = ReflectionKind.string;
+    readonly name: "stringFormat";
+    getIgnoredProps(): string[] | undefined;
+    emitFormat(comp: JitFnCompiler, rt: BaseRunType): JitCode;
+    emitIsType(comp: JitFnCompiler, rt: BaseRunType): JitCode;
+    emitIsTypeErrors(comp: JitErrorsFnCompiler, rt: BaseRunType): JitCode;
+    _mock(opts: RunTypeOptions, rt: BaseRunType, params?: StringParams): string;
+    private mockString;
+    validateParams(rt: BaseRunType, p: StringParams): void;
+}
+export declare function isPatternParam(p: any): p is FormatParam_Pattern;
+export declare function patternParamsToStrParams(p: FormatParam_Pattern): StringParams;
+export declare const STRING_RUN_TYPE_FORMATTER: StringRunTypeFormat;
+export type FormatString<P extends StringParams = {}, BrandName extends string = never> = TypeFormat<string, typeof StringRunTypeFormat.id, P, BrandName>;
+export declare type __ΩFormatString = any[];