@mionjs/type-formats 0.8.0-alpha.0

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

@@ -0,0 +1,100 @@
+import { registerFormatter, BaseRunTypeFormat, __ΩTypeFormat as ___TypeFormat } from "@mionjs/run-types";
+import { ReflectionKind } from "@deepkit/type";
+import { paramVal } from "../utils.js";
+import { cpf_isSeconds, cpf_isMinutes, cpf_isHours, cpf_isTimeString_mmss, cpf_isTimeString_HHmm, cpf_isTimeString_HHmmss, cpf_isTimeString_ISO, cpf_isTimeString_ISO_TZ } from "../type-formats-pure-fns.js";
+class TimeStringRunTypeFormat extends BaseRunTypeFormat {
+  static id = "time";
+  kind = ReflectionKind.string;
+  name = TimeStringRunTypeFormat.id;
+  emitIsType(comp, rt) {
+    const params = this.getParams(rt);
+    const formatFn = this.getFormatPureFn(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", 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 (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: ${paramVal(params.format)}`);
+    }
+  }
+  getFormatPureFn(format) {
+    switch (format) {
+      case "ISO":
+      case "HH:mm:ss[.mmm]TZ":
+        return cpf_isTimeString_ISO_TZ;
+      case "HH:mm:ss[.mmm]":
+        return cpf_isTimeString_ISO;
+      case "HH:mm:ss":
+        return cpf_isTimeString_HHmmss;
+      case "HH:mm":
+        return cpf_isTimeString_HHmm;
+      case "mm:ss":
+        return cpf_isTimeString_mmss;
+      case "HH":
+        return cpf_isHours;
+      case "mm":
+        return cpf_isMinutes;
+      case "ss":
+        return 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 = 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", () => ___TypeFormat, () => TimeStringRunTypeFormat.id, "time", "FormatStringTime", 'n!c"&i$e!!.%o#%w&y'];
+export {
+  TIME_RUN_TYPE_FORMATTER,
+  TimeStringRunTypeFormat,
+  __ΩDEFAULT_TIME_FORMAT_PARAMS,
+  __ΩFormatStringTime,
+  mockMilliseconds,
+  mockTimeZone
+};
+//# sourceMappingURL=time.runtype.js.map

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

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

package/.dist/esm/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/esm/src/string/url.runtype.js

@@ -0,0 +1,160 @@
+import { registerFormatter, BaseRunTypeFormat, randomItem, JitFunctions, __ΩTypeFormat as ___TypeFormat } from "@mionjs/run-types";
+import { ReflectionKind } from "@deepkit/type";
+import { StringRunTypeFormat, stringIgnoreProps } from "./stringFormat.runtype.js";
+import { DomainRunTypeFormat } from "./domain.runtype.js";
+import { IPRunTypeFormat } from "./ip.runtype.js";
+import { INTERNET_PROTOCOLS, __ΩFILE_URL_SAMPLES as ___FILE_URL_SAMPLES, __ΩHTTP_URL_SAMPLES as ___HTTP_URL_SAMPLES, __ΩURL_SAMPLES as ___URL_SAMPLES, __ΩSOCIAL_MEDIA_DOMAINS_SAMPLES as ___SOCIAL_MEDIA_DOMAINS_SAMPLES, __ΩSOCIAL_MEDIA_URL_SAMPLES as ___SOCIAL_MEDIA_URL_SAMPLES } from "../constants.mock.js";
+import { paramVal } from "../utils.js";
+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 BaseRunTypeFormat {
+  static id = "url";
+  kind = 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 StringRunTypeFormat(urlPath);
+    this.domainFormatter = new DomainRunTypeFormat(domainPath);
+    this.ipFormatter = new IPRunTypeFormat(ipPath);
+  }
+  getIgnoredProps() {
+    return 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 = randomItem(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 && paramVal(params.maxLength) > 2048)
+      throw new Error("URL maxLength cannot be greater than 2048");
+    if (params.minLength && 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 = 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 = registerFormatter(new URLRunTypeFormat());
+const __ΩDEFAULT_URL_PARAMS = [2048, "maxLength", () => URL_REGEXP, "val", "invalid URL format", "errorMessage", () => ___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", () => ___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", () => ___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 = [() => ___SOCIAL_MEDIA_DOMAINS_SAMPLES, "DomainLIst", 2048, "maxLength", () => URL_HTTP_REGEXP, "val", "invalid social media URL format", "errorMessage", () => ___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", () => ___TypeFormat, "url", () => __ΩDEFAULT_URL_PARAMS, "url", "FormatUrl", 'PMc!&.#Pn$e"!K.%o"%w&y'];
+const __ΩFormatUrlFile = ["P", () => ___TypeFormat, "url", () => __ΩDEFAULT_URL_FILE_PARAMS, "url", "FormatUrlFile", 'PMc!&.#Pn$e"!K.%o"%w&y'];
+const __ΩFormatUrlHttp = ["P", () => ___TypeFormat, "url", () => __ΩDEFAULT_URL_HTTP_PARAMS, "url", "FormatUrlHttp", 'PMc!&.#Pn$e"!K.%o"%w&y'];
+const __ΩFormatUrlSocialMedia = [() => ___SOCIAL_MEDIA_DOMAINS_SAMPLES, "DomainLIst", () => __ΩFormatUrl, () => __ΩDEFAULT_URL_SOCIAL_MEDIA_PARAMS, "FormatUrlSocialMedia", 'n!c"e!!o$"o#"w%y'];
+export {
+  URLRunTypeFormat,
+  URL_FILE_REGEXP,
+  URL_HTTP_REGEXP,
+  URL_REGEXP,
+  URL_RUN_TYPE_FORMATTER,
+  __ΩDEFAULT_URL_FILE_PARAMS,
+  __ΩDEFAULT_URL_HTTP_PARAMS,
+  __ΩDEFAULT_URL_PARAMS,
+  __ΩDEFAULT_URL_SOCIAL_MEDIA_PARAMS,
+  __ΩFormatUrl,
+  __ΩFormatUrlFile,
+  __ΩFormatUrlHttp,
+  __ΩFormatUrlSocialMedia
+};
+//# sourceMappingURL=url.runtype.js.map

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

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

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

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

@@ -0,0 +1,44 @@
+import { registerFormatter, BaseRunTypeFormat, __ΩTypeFormat as ___TypeFormat } from "@mionjs/run-types";
+import { ReflectionKind } from "@deepkit/type";
+import { randomUUID_V7 } from "@mionjs/core";
+import { paramVal } from "../utils.js";
+import { cpf_isUUID } from "../type-formats-pure-fns.js";
+class UUIDRunTypeFormat extends BaseRunTypeFormat {
+  static id = "uuid";
+  kind = ReflectionKind.string;
+  name = UUIDRunTypeFormat.id;
+  emitIsType(comp, rt) {
+    const params = this.getParams(rt);
+    return { code: this.compilePureFunctionCall(comp, rt, 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", paramVal(params.version))}`, type: "S" };
+  }
+  _mock(opts, rt) {
+    const params = this.getParams(rt);
+    return params.version === "4" ? crypto.randomUUID() : 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 = registerFormatter(new UUIDRunTypeFormat());
+const __ΩFormatUUIDv4 = [() => ___TypeFormat, () => UUIDRunTypeFormat.id, "4", "version", "uuid", "FormatUUIDv4", '&i"P.#4$M.%o!%w&y'];
+const __ΩFormatUUIDv7 = [() => ___TypeFormat, () => UUIDRunTypeFormat.id, "7", "version", "uuid", "FormatUUIDv7", '&i"P.#4$M.%o!%w&y'];
+export {
+  UUIDRunTypeFormat,
+  UUID_RUN_TYPE_FORMATTER,
+  __ΩFormatUUIDv4,
+  __ΩFormatUUIDv7
+};
+//# sourceMappingURL=uuid.runtype.js.map

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

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

package/.dist/esm/src/type-formats-pure-fns.d.ts

@@ -0,0 +1,27 @@
+export declare const cpf_isDateString: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isDateString_YMD: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isDateString_DMY: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isDateString_MDY: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isDateString_YM: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isDateString_MD: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isDateString_DM: import('@mionjs/core').CompiledPureFunction;
+export declare const dateFunctions: import('@mionjs/core').CompiledPureFunction[];
+export declare const cpf_isTimeZone: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isHours: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isMinutes: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isSeconds: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isSecondsWithMs: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isTimeString_ISO_TZ: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isTimeString_ISO: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isTimeString_HHmmss: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isTimeString_HHmm: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isTimeString_mmss: import('@mionjs/core').CompiledPureFunction;
+export declare const pureTimeFns: import('@mionjs/core').CompiledPureFunction[];
+export declare const timeFunctions: import('@mionjs/core').CompiledPureFunction[];
+export declare const cpf_isUUID: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isLocalHost: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isIPV4: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_isIPV6: import('@mionjs/core').CompiledPureFunction;
+export declare const cpf_mionGetIPErrors: import('@mionjs/core').CompiledPureFunction;
+export declare const ipFunctions: import('@mionjs/core').CompiledPureFunction[];
+export declare const mionFormatsPureFunctions: import('@mionjs/core').CompiledPureFunction[];