@mionjs/type-formats 0.8.0-alpha.0

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

@@ -0,0 +1,100 @@
+"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 TimeStringRunTypeFormat extends runTypes.BaseRunTypeFormat {
+  static id = "time";
+  kind = type.ReflectionKind.string;
+  name = TimeStringRunTypeFormat.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 hours = String(Math.floor(Math.random() * 24)).padStart(2, "0");
+    const minutes = String(Math.floor(Math.random() * 60)).padStart(2, "0");
+    const seconds = String(Math.floor(Math.random() * 60)).padStart(2, "0");
+    switch (src_utils.paramVal(params.format)) {
+      case "ISO":
+      // ISO
+      case "HH:mm:ss[.mmm]TZ":
+        return `${hours}:${minutes}:${seconds}${mockMilliseconds()}${mockTimeZone()}`;
+      case "HH:mm:ss[.mmm]":
+        return `${hours}:${minutes}:${seconds}${mockMilliseconds()}`;
+      case "HH:mm:ss":
+        return `${hours}:${minutes}:${seconds}`;
+      case "HH:mm":
+        return `${hours}:${minutes}`;
+      case "mm:ss":
+        return `${minutes}:${seconds}`;
+      case "HH":
+        return hours;
+      case "mm":
+        return minutes;
+      case "ss":
+        return seconds;
+      default:
+        throw new Error(`Invalid time format: ${src_utils.paramVal(params.format)}`);
+    }
+  }
+  getFormatPureFn(format) {
+    switch (format) {
+      case "ISO":
+      case "HH:mm:ss[.mmm]TZ":
+        return src_typeFormatsPureFns.cpf_isTimeString_ISO_TZ;
+      case "HH:mm:ss[.mmm]":
+        return src_typeFormatsPureFns.cpf_isTimeString_ISO;
+      case "HH:mm:ss":
+        return src_typeFormatsPureFns.cpf_isTimeString_HHmmss;
+      case "HH:mm":
+        return src_typeFormatsPureFns.cpf_isTimeString_HHmm;
+      case "mm:ss":
+        return src_typeFormatsPureFns.cpf_isTimeString_mmss;
+      case "HH":
+        return src_typeFormatsPureFns.cpf_isHours;
+      case "mm":
+        return src_typeFormatsPureFns.cpf_isMinutes;
+      case "ss":
+        return src_typeFormatsPureFns.cpf_isSeconds;
+      default:
+        throw new Error(`Invalid time format: ${format}`);
+    }
+  }
+}
+function mockMilliseconds() {
+  const showMilliseconds = Math.random() > 0.5;
+  if (!showMilliseconds)
+    return "";
+  return `.${String(Math.floor(Math.random() * 1e3)).padStart(3, "0")}`;
+}
+function mockTimeZone() {
+  const isZ = Math.random() > 0.5;
+  if (isZ)
+    return "Z";
+  const hours = String(Math.floor(Math.random() * 24)).padStart(2, "0");
+  const minutes = String(Math.floor(Math.random() * 60)).padStart(2, "0");
+  return `${Math.random() > 0.5 ? "+" : "-"}${hours}:${minutes}`;
+}
+const TIME_RUN_TYPE_FORMATTER = runTypes.registerFormatter(new TimeStringRunTypeFormat());
+const __ΩDEFAULT_TIME_FORMAT_PARAMS = ["ISO", "format", "DEFAULT_TIME_FORMAT_PARAMS", 'P.!4"Mw#y'];
+const __ΩFormatStringTime = [() => __ΩDEFAULT_TIME_FORMAT_PARAMS, "P", () => runTypes.__ΩTypeFormat, () => TimeStringRunTypeFormat.id, "time", "FormatStringTime", 'n!c"&i$e!!.%o#%w&y'];
+exports.TIME_RUN_TYPE_FORMATTER = TIME_RUN_TYPE_FORMATTER;
+exports.TimeStringRunTypeFormat = TimeStringRunTypeFormat;
+exports.__ΩDEFAULT_TIME_FORMAT_PARAMS = __ΩDEFAULT_TIME_FORMAT_PARAMS;
+exports.__ΩFormatStringTime = __ΩFormatStringTime;
+exports.mockMilliseconds = mockMilliseconds;
+exports.mockTimeZone = mockTimeZone;
+//# sourceMappingURL=time.runtype.cjs.map

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

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

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

@@ -0,0 +1,21 @@
+import { BaseRunType, JitFnCompiler, JitErrorsFnCompiler, JitCode, BaseRunTypeFormat, TypeFormat, RunTypeOptions } from '@mionjs/run-types';
+import { ReflectionKind } from '@deepkit/type';
+import { FormatParams_Time } from '@mionjs/core';
+export declare class TimeStringRunTypeFormat extends BaseRunTypeFormat<FormatParams_Time> {
+    static id: "time";
+    kind: ReflectionKind;
+    name: "time";
+    emitIsType(comp: JitFnCompiler, rt: BaseRunType): JitCode;
+    emitIsTypeErrors(comp: JitErrorsFnCompiler, rt: BaseRunType): JitCode;
+    _mock(opts: RunTypeOptions, rt: BaseRunType): string;
+    getFormatPureFn(format: FormatStringTime): import('@mionjs/core').CompiledPureFunction;
+}
+export declare function mockMilliseconds(): string;
+export declare function mockTimeZone(): string;
+export declare const TIME_RUN_TYPE_FORMATTER: TimeStringRunTypeFormat;
+export type DEFAULT_TIME_FORMAT_PARAMS = {
+    format: 'ISO';
+};
+export type FormatStringTime<P extends FormatParams_Time = DEFAULT_TIME_FORMAT_PARAMS> = TypeFormat<string, typeof TimeStringRunTypeFormat.id, P, 'time'>;
+export declare type __ΩDEFAULT_TIME_FORMAT_PARAMS = any[];
+export declare type __ΩFormatStringTime = any[];

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

@@ -0,0 +1,160 @@
+"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_string_domain_runtype = require("./domain.runtype.cjs");
+const src_string_ip_runtype = require("./ip.runtype.cjs");
+const src_constants_mock = require("../constants.mock.cjs");
+const src_utils = require("../utils.cjs");
+const URL_REGEXP = /^(?:https?|ftps?|wss?):\/\/[^\s/$.?#-][^\s]*$/i;
+const URL_FILE_REGEXP = /^file:\/\/\/?(?:[a-zA-Z]:)?[^\s/$.?#-][^\s]*$/i;
+const URL_HTTP_REGEXP = /^https?:\/\/[^\s/$.?#-][^\s]*$/i;
+class URLRunTypeFormat extends runTypes.BaseRunTypeFormat {
+  static id = "url";
+  kind = type.ReflectionKind.string;
+  name = URLRunTypeFormat.id;
+  // Formatter instances as class variables
+  urlFormatter;
+  domainFormatter;
+  ipFormatter;
+  constructor(parentPath) {
+    super(parentPath);
+    const urlPath = this.getFormatPath();
+    const domainPath = this.getFormatPath("domain");
+    const ipPath = this.getFormatPath("ip");
+    this.urlFormatter = new src_string_stringFormat_runtype.StringRunTypeFormat(urlPath);
+    this.domainFormatter = new src_string_domain_runtype.DomainRunTypeFormat(domainPath);
+    this.ipFormatter = new src_string_ip_runtype.IPRunTypeFormat(ipPath);
+  }
+  getIgnoredProps() {
+    return src_string_stringFormat_runtype.stringIgnoreProps;
+  }
+  emitIsType(comp, rt) {
+    const params = this.getParams(rt);
+    const fnID = comp.fnID;
+    const fmtName = this.getFormatName();
+    const urlCode = this.urlFormatter.compileFormat(fnID, comp, rt, params, comp.vλl, fmtName);
+    if (!params.domain && !params.ip)
+      return urlCode;
+    const vDomain = "domain";
+    const dmnCode = params?.domain ? this.domainFormatter.compileFormat(fnID, comp, rt, params.domain, vDomain, fmtName) : null;
+    const ipCodeObj = params.ip ? this.ipFormatter.compileFormat(fnID, comp, rt, params.ip, vDomain, fmtName) : null;
+    const safeUrlCode = urlCode.code ? `if(!(${urlCode.code})) return false;` : "";
+    const dIsExpression = dmnCode?.type === "E";
+    const ipExpression = ipCodeObj?.type === "E";
+    const domainSafeCode = dIsExpression && dmnCode?.code ? `if(!(${dmnCode.code})) return false;` : dmnCode?.code;
+    const ipSafeCode = ipExpression && ipCodeObj?.code ? `if(${ipCodeObj.code}) return false;` : ipCodeObj?.code;
+    const returnCode = this.isRootFormat() ? `return true;` : "";
+    const code = `
+            ${safeUrlCode}
+            const start = ${comp.vλl}.indexOf('://') + 3;
+            const end = ${comp.vλl}.indexOf('/', start);
+            const endIdx = end === -1 ? ${comp.vλl}.length : end;
+            const domain = ${comp.vλl}.substring(start, endIdx);
+            ${domainSafeCode}
+            ${ipSafeCode}
+            ${returnCode}
+        `;
+    return { code, type: "S" };
+  }
+  emitIsTypeErrors(comp, rt) {
+    const params = this.getParams(rt);
+    const fnID = comp.fnID;
+    const fmtName = this.getFormatName();
+    const urlCode = this.urlFormatter.compileFormat(fnID, comp, rt, params, comp.vλl, fmtName);
+    if (!params.domain && !params.ip)
+      return urlCode;
+    const vDomain = "domain" + this.getFormatNestLevel();
+    const dmnCode = params?.domain ? this.domainFormatter.compileFormat(fnID, comp, rt, params.domain, vDomain, fmtName) : null;
+    const iPCode = params.ip ? this.ipFormatter.compileFormat(fnID, comp, rt, params.ip, vDomain, fmtName) : null;
+    const checks = [urlCode.code, dmnCode?.code, iPCode?.code].filter(Boolean);
+    const vStart = "start" + this.getFormatNestLevel();
+    const vEnd = "end" + this.getFormatNestLevel();
+    const vEndIdx = "endIdx" + this.getFormatNestLevel();
+    const code = `
+            const ${vStart} = ${comp.vλl}.indexOf('://') + 3;
+            const ${vEnd} = ${comp.vλl}.indexOf('/', ${vStart});
+            const ${vEndIdx} = ${vEnd} === -1 ? ${comp.vλl}.length : ${vEnd};
+            const ${vDomain} = ${comp.vλl}.substring(${vStart}, ${vEndIdx});
+            ${checks.join(";")};
+        `;
+    return { code, type: "S" };
+  }
+  _mock(opts, rt) {
+    const params = this.getParams(rt);
+    let url = this.urlFormatter.mock(opts, rt, params);
+    const hasProtocol = url.indexOf("://") !== -1;
+    if (!hasProtocol)
+      url = runTypes.randomItem(src_constants_mock.INTERNET_PROTOCOLS) + url;
+    if (params.domain) {
+      const domain = this.domainFormatter.mock(opts, rt, params.domain);
+      return replaceDomain(url, domain);
+    }
+    if (params.ip)
+      return replaceDomain(url, this.ipFormatter.mock(opts, rt, params.ip));
+    return url;
+  }
+  validateParams(rt, params) {
+    if (params.maxLength && src_utils.paramVal(params.maxLength) > 2048)
+      throw new Error("URL maxLength cannot be greater than 2048");
+    if (params.minLength && src_utils.paramVal(params.minLength) < 5)
+      throw new Error("URL minLength cannot be less than 5");
+    this.urlFormatter.validateParams(rt, params);
+    const { ip, domain } = params;
+    if (ip && domain)
+      throw new Error("URL validator cannot have both IP and domain validators");
+    if (domain) {
+      this.domainFormatter.validateParams(rt, domain);
+    }
+  }
+  emitFormat(comp, rt) {
+    const params = this.getParams(rt);
+    if (!params.domain)
+      return { code: void 0, type: "S" };
+    const vDomain = "domain" + this.getFormatNestLevel();
+    const fnID = runTypes.JitFunctions.format.id;
+    const fmtName = this.getFormatName();
+    const domainCode = this.domainFormatter.compileFormat(fnID, comp, rt, params.domain, vDomain, fmtName);
+    const vStart = "start" + this.getFormatNestLevel();
+    const vEnd = "end" + this.getFormatNestLevel();
+    const vEndIdx = "endIdx" + this.getFormatNestLevel();
+    const code = `
+            const ${vStart} = ${comp.vλl}.indexOf('://') + 3;
+            const ${vEnd} = ${comp.vλl}.indexOf('/', ${vStart});
+            const ${vEndIdx} = ${vEnd} === -1 ? ${comp.vλl}.length : ${vEnd};
+            const ${vDomain} = ${comp.vλl}.substring(${vStart}, ${vEndIdx});
+            return ${domainCode.code};
+        `;
+    return { code, type: "RB" };
+  }
+}
+function replaceDomain(url, domain) {
+  const start = url.indexOf("://") + 3;
+  const end = url.indexOf("/", start);
+  const endIdx = end === -1 ? url.length : end;
+  return url.substring(0, start) + domain + url.substring(endIdx);
+}
+const URL_RUN_TYPE_FORMATTER = runTypes.registerFormatter(new URLRunTypeFormat());
+const __ΩDEFAULT_URL_PARAMS = [2048, "maxLength", () => URL_REGEXP, "val", "invalid URL format", "errorMessage", () => src_constants_mock.__ΩURL_SAMPLES, "mockSamples", "pattern", "DEFAULT_URL_PARAMS", `P.!4"Pi#4$.%4&n'4(M4)Mw*y`];
+const __ΩDEFAULT_URL_FILE_PARAMS = [2048, "maxLength", () => URL_FILE_REGEXP, "val", "invalid file URL format", "errorMessage", () => src_constants_mock.__ΩFILE_URL_SAMPLES, "mockSamples", "pattern", "DEFAULT_URL_FILE_PARAMS", `P.!4"Pi#4$.%4&n'4(M4)Mw*y`];
+const __ΩDEFAULT_URL_HTTP_PARAMS = [2048, "maxLength", () => URL_HTTP_REGEXP, "val", "invalid Http URL format", "errorMessage", () => src_constants_mock.__ΩHTTP_URL_SAMPLES, "mockSamples", "pattern", "DEFAULT_URL_HTTP_PARAMS", `P.!4"Pi#4$.%4&n'4(M4)Mw*y`];
+const __ΩDEFAULT_URL_SOCIAL_MEDIA_PARAMS = [() => src_constants_mock.__ΩSOCIAL_MEDIA_DOMAINS_SAMPLES, "DomainLIst", 2048, "maxLength", () => URL_HTTP_REGEXP, "val", "invalid social media URL format", "errorMessage", () => src_constants_mock.__ΩSOCIAL_MEDIA_URL_SAMPLES, "mockSamples", "pattern", "Only social media domains are allowed", "allowedValues", "names", "com", "Only com TLDs are allowed", "tld", "domain", "DEFAULT_URL_SOCIAL_MEDIA_PARAMS", `n!c"P.#4$Pi%4&.'4(n)4*M4+PPPe%!4&.,4(M4-M4.PPP./G4&.04(M4-M41M42Mw3y`];
+const __ΩFormatUrl = ["P", () => runTypes.__ΩTypeFormat, "url", () => __ΩDEFAULT_URL_PARAMS, "url", "FormatUrl", 'PMc!&.#Pn$e"!K.%o"%w&y'];
+const __ΩFormatUrlFile = ["P", () => runTypes.__ΩTypeFormat, "url", () => __ΩDEFAULT_URL_FILE_PARAMS, "url", "FormatUrlFile", 'PMc!&.#Pn$e"!K.%o"%w&y'];
+const __ΩFormatUrlHttp = ["P", () => runTypes.__ΩTypeFormat, "url", () => __ΩDEFAULT_URL_HTTP_PARAMS, "url", "FormatUrlHttp", 'PMc!&.#Pn$e"!K.%o"%w&y'];
+const __ΩFormatUrlSocialMedia = [() => src_constants_mock.__ΩSOCIAL_MEDIA_DOMAINS_SAMPLES, "DomainLIst", () => __ΩFormatUrl, () => __ΩDEFAULT_URL_SOCIAL_MEDIA_PARAMS, "FormatUrlSocialMedia", 'n!c"e!!o$"o#"w%y'];
+exports.URLRunTypeFormat = URLRunTypeFormat;
+exports.URL_FILE_REGEXP = URL_FILE_REGEXP;
+exports.URL_HTTP_REGEXP = URL_HTTP_REGEXP;
+exports.URL_REGEXP = URL_REGEXP;
+exports.URL_RUN_TYPE_FORMATTER = URL_RUN_TYPE_FORMATTER;
+exports.__ΩDEFAULT_URL_FILE_PARAMS = __ΩDEFAULT_URL_FILE_PARAMS;
+exports.__ΩDEFAULT_URL_HTTP_PARAMS = __ΩDEFAULT_URL_HTTP_PARAMS;
+exports.__ΩDEFAULT_URL_PARAMS = __ΩDEFAULT_URL_PARAMS;
+exports.__ΩDEFAULT_URL_SOCIAL_MEDIA_PARAMS = __ΩDEFAULT_URL_SOCIAL_MEDIA_PARAMS;
+exports.__ΩFormatUrl = __ΩFormatUrl;
+exports.__ΩFormatUrlFile = __ΩFormatUrlFile;
+exports.__ΩFormatUrlHttp = __ΩFormatUrlHttp;
+exports.__ΩFormatUrlSocialMedia = __ΩFormatUrlSocialMedia;
+//# sourceMappingURL=url.runtype.cjs.map

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

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

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

@@ -0,0 +1,81 @@
+import { BaseRunType, JitFnCompiler, JitErrorsFnCompiler, JitCode, StrNumber, BaseRunTypeFormat, TypeFormat, RunTypeOptions } from '@mionjs/run-types';
+import { ReflectionKind } from '@deepkit/type';
+import { FormatParams_Url } from '@mionjs/core';
+import { FILE_URL_SAMPLES, HTTP_URL_SAMPLES, SOCIAL_MEDIA_URL_SAMPLES, URL_SAMPLES, SOCIAL_MEDIA_DOMAINS_SAMPLES } from '../constants.mock.ts';
+export declare const URL_REGEXP: RegExp;
+export declare const URL_FILE_REGEXP: RegExp;
+export declare const URL_HTTP_REGEXP: RegExp;
+export declare class URLRunTypeFormat extends BaseRunTypeFormat<FormatParams_Url> {
+    static readonly id = "url";
+    readonly kind = ReflectionKind.string;
+    readonly name = "url";
+    private urlFormatter;
+    private domainFormatter;
+    private ipFormatter;
+    constructor(parentPath?: StrNumber[]);
+    getIgnoredProps(): string[] | undefined;
+    emitIsType(comp: JitFnCompiler, rt: BaseRunType): JitCode;
+    emitIsTypeErrors(comp: JitErrorsFnCompiler, rt: BaseRunType): JitCode;
+    _mock(opts: RunTypeOptions, rt: BaseRunType): string;
+    validateParams(rt: BaseRunType, params: FormatParams_Url): void;
+    emitFormat(comp: JitFnCompiler, rt: BaseRunType): JitCode;
+}
+export declare const URL_RUN_TYPE_FORMATTER: URLRunTypeFormat;
+export type DEFAULT_URL_PARAMS = {
+    maxLength: 2048;
+    pattern: {
+        val: typeof URL_REGEXP;
+        errorMessage: 'invalid URL format';
+        mockSamples: URL_SAMPLES;
+    };
+};
+export type DEFAULT_URL_FILE_PARAMS = {
+    maxLength: 2048;
+    pattern: {
+        val: typeof URL_FILE_REGEXP;
+        errorMessage: 'invalid file URL format';
+        mockSamples: FILE_URL_SAMPLES;
+    };
+};
+export type DEFAULT_URL_HTTP_PARAMS = {
+    maxLength: 2048;
+    pattern: {
+        val: typeof URL_HTTP_REGEXP;
+        errorMessage: 'invalid Http URL format';
+        mockSamples: HTTP_URL_SAMPLES;
+    };
+};
+export type DEFAULT_URL_SOCIAL_MEDIA_PARAMS<DomainLIst extends readonly string[] = SOCIAL_MEDIA_DOMAINS_SAMPLES> = {
+    maxLength: 2048;
+    pattern: {
+        val: typeof URL_HTTP_REGEXP;
+        errorMessage: 'invalid social media URL format';
+        mockSamples: SOCIAL_MEDIA_URL_SAMPLES;
+    };
+    domain: {
+        names: {
+            allowedValues: {
+                val: DomainLIst;
+                errorMessage: 'Only social media domains are allowed';
+            };
+        };
+        tld: {
+            allowedValues: {
+                val: ['com'];
+                errorMessage: 'Only com TLDs are allowed';
+            };
+        };
+    };
+};
+export type FormatUrl<P extends FormatParams_Url = {}> = TypeFormat<string, 'url', DEFAULT_URL_PARAMS & P, 'url'>;
+export type FormatUrlFile<P extends FormatParams_Url = {}> = TypeFormat<string, 'url', DEFAULT_URL_FILE_PARAMS & P, 'url'>;
+export type FormatUrlHttp<P extends FormatParams_Url = {}> = TypeFormat<string, 'url', DEFAULT_URL_HTTP_PARAMS & P, 'url'>;
+export type FormatUrlSocialMedia<DomainLIst extends readonly string[] = SOCIAL_MEDIA_DOMAINS_SAMPLES> = FormatUrl<DEFAULT_URL_SOCIAL_MEDIA_PARAMS<DomainLIst>>;
+export declare type __ΩDEFAULT_URL_PARAMS = any[];
+export declare type __ΩDEFAULT_URL_FILE_PARAMS = any[];
+export declare type __ΩDEFAULT_URL_HTTP_PARAMS = any[];
+export declare type __ΩDEFAULT_URL_SOCIAL_MEDIA_PARAMS = any[];
+export declare type __ΩFormatUrl = any[];
+export declare type __ΩFormatUrlFile = any[];
+export declare type __ΩFormatUrlHttp = any[];
+export declare type __ΩFormatUrlSocialMedia = any[];

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const runTypes = require("@mionjs/run-types");
+const type = require("@deepkit/type");
+const core = require("@mionjs/core");
+const src_utils = require("../utils.cjs");
+const src_typeFormatsPureFns = require("../type-formats-pure-fns.cjs");
+class UUIDRunTypeFormat extends runTypes.BaseRunTypeFormat {
+  static id = "uuid";
+  kind = type.ReflectionKind.string;
+  name = UUIDRunTypeFormat.id;
+  emitIsType(comp, rt) {
+    const params = this.getParams(rt);
+    return { code: this.compilePureFunctionCall(comp, rt, src_typeFormatsPureFns.cpf_isUUID, params).callCode, type: "E" };
+  }
+  emitIsTypeErrors(comp, rt) {
+    const params = this.getParams(rt);
+    const isTypeCodeObj = this.emitIsType(comp, rt);
+    const isTypeCode = isTypeCodeObj.code;
+    if (!isTypeCode)
+      return { code: "", type: "S" };
+    const errFn = this.getCallJitFormatErr(comp, rt, this);
+    return { code: `if (!(${isTypeCode})) ${errFn("version", src_utils.paramVal(params.version))}`, type: "S" };
+  }
+  _mock(opts, rt) {
+    const params = this.getParams(rt);
+    return params.version === "4" ? crypto.randomUUID() : core.randomUUID_V7();
+  }
+  validateParams(_rt, params) {
+    if (params.version !== "4" && params.version !== "7") {
+      throw new Error(`Invalid UUID version: ${params.version}, must be either 4 or 7`);
+    }
+  }
+  emitFormat;
+  // no format needed
+}
+const UUID_RUN_TYPE_FORMATTER = runTypes.registerFormatter(new UUIDRunTypeFormat());
+const __ΩFormatUUIDv4 = [() => runTypes.__ΩTypeFormat, () => UUIDRunTypeFormat.id, "4", "version", "uuid", "FormatUUIDv4", '&i"P.#4$M.%o!%w&y'];
+const __ΩFormatUUIDv7 = [() => runTypes.__ΩTypeFormat, () => UUIDRunTypeFormat.id, "7", "version", "uuid", "FormatUUIDv7", '&i"P.#4$M.%o!%w&y'];
+exports.UUIDRunTypeFormat = UUIDRunTypeFormat;
+exports.UUID_RUN_TYPE_FORMATTER = UUID_RUN_TYPE_FORMATTER;
+exports.__ΩFormatUUIDv4 = __ΩFormatUUIDv4;
+exports.__ΩFormatUUIDv7 = __ΩFormatUUIDv7;
+//# sourceMappingURL=uuid.runtype.cjs.map

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

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

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

@@ -0,0 +1,22 @@
+import { BaseRunType, JitFnCompiler, JitErrorsFnCompiler, JitCode, BaseRunTypeFormat, RunTypeOptions, TypeFormat } from '@mionjs/run-types';
+import { ReflectionKind } from '@deepkit/type';
+import { FormatParams_UUID } from '@mionjs/core';
+export declare class UUIDRunTypeFormat extends BaseRunTypeFormat<FormatParams_UUID> {
+    static readonly id: "uuid";
+    readonly kind = ReflectionKind.string;
+    readonly name: "uuid";
+    emitIsType(comp: JitFnCompiler, rt: BaseRunType): JitCode;
+    emitIsTypeErrors(comp: JitErrorsFnCompiler, rt: BaseRunType): JitCode;
+    _mock(opts: RunTypeOptions, rt: BaseRunType): string;
+    validateParams(_rt: BaseRunType, params: FormatParams_UUID): void;
+    emitFormat?: any;
+}
+export declare const UUID_RUN_TYPE_FORMATTER: UUIDRunTypeFormat;
+export type FormatUUIDv4 = TypeFormat<string, typeof UUIDRunTypeFormat.id, {
+    version: '4';
+}, 'uuid'>;
+export type FormatUUIDv7 = TypeFormat<string, typeof UUIDRunTypeFormat.id, {
+    version: '7';
+}, 'uuid'>;
+export declare type __ΩFormatUUIDv4 = any[];
+export declare type __ΩFormatUUIDv7 = any[];