@mionjs/run-types 0.8.10 → 0.13.2

package/dist/cjs/formats/numberFormats.d.ts

@@ -0,0 +1,82 @@
+import { TypeFormat } from '../runtypes/typeFormat.ts';
+export interface NumberParams {
+    integer?: boolean;
+    float?: boolean;
+    min?: number;
+    max?: number;
+    lt?: number;
+    gt?: number;
+    multipleOf?: number;
+    multipleOfTolerance?: number;
+    minimum?: number;
+    maximum?: number;
+    exclusiveMinimum?: number;
+    exclusiveMaximum?: number;
+    isCurrency?: boolean;
+}
+export type Number<P extends NumberParams = {}, BrandName extends string = never> = TypeFormat<number, 'numberFormat', P, BrandName>;
+export type Currency<P extends NumberParams = {}, BrandName extends string = never> = Number<P & {
+    isCurrency: true;
+}, BrandName>;
+export type Integer = Number<{
+    integer: true;
+}>;
+export type Float = Number<{
+    float: true;
+}>;
+export type Positive = Number<{
+    min: 0;
+}>;
+export type Negative = Number<{
+    max: 0;
+}>;
+export type PositiveInt = Number<{
+    min: 0;
+    integer: true;
+}>;
+export type NegativeInt = Number<{
+    max: 0;
+    integer: true;
+}>;
+export type Int8 = Number<{
+    integer: true;
+    min: -128;
+    max: 127;
+}>;
+export type Int16 = Number<{
+    integer: true;
+    min: -32768;
+    max: 32767;
+}>;
+export type Int32 = Number<{
+    integer: true;
+    min: -2147483648;
+    max: 2147483647;
+}>;
+export type UInt8 = Number<{
+    integer: true;
+    min: 0;
+    max: 255;
+}>;
+export type UInt16 = Number<{
+    integer: true;
+    min: 0;
+    max: 65535;
+}>;
+export type UInt32 = Number<{
+    integer: true;
+    min: 0;
+    max: 4294967295;
+}>;
+export declare const integer: (id?: import("../markers.ts").InjectRunTypeId<Integer> | undefined) => import("../index.ts").RunType<Integer>;
+export declare const float: (id?: import("../markers.ts").InjectRunTypeId<Float> | undefined) => import("../index.ts").RunType<Float>;
+export declare const positive: (id?: import("../markers.ts").InjectRunTypeId<Positive> | undefined) => import("../index.ts").RunType<Positive>;
+export declare const negative: (id?: import("../markers.ts").InjectRunTypeId<Negative> | undefined) => import("../index.ts").RunType<Negative>;
+export declare const positiveInt: (id?: import("../markers.ts").InjectRunTypeId<PositiveInt> | undefined) => import("../index.ts").RunType<PositiveInt>;
+export declare const negativeInt: (id?: import("../markers.ts").InjectRunTypeId<NegativeInt> | undefined) => import("../index.ts").RunType<NegativeInt>;
+export declare const int8: (id?: import("../markers.ts").InjectRunTypeId<Int8> | undefined) => import("../index.ts").RunType<Int8>;
+export declare const int16: (id?: import("../markers.ts").InjectRunTypeId<Int16> | undefined) => import("../index.ts").RunType<Int16>;
+export declare const int32: (id?: import("../markers.ts").InjectRunTypeId<Int32> | undefined) => import("../index.ts").RunType<Int32>;
+export declare const uint8: (id?: import("../markers.ts").InjectRunTypeId<UInt8> | undefined) => import("../index.ts").RunType<UInt8>;
+export declare const uint16: (id?: import("../markers.ts").InjectRunTypeId<UInt16> | undefined) => import("../index.ts").RunType<UInt16>;
+export declare const uint32: (id?: import("../markers.ts").InjectRunTypeId<UInt32> | undefined) => import("../index.ts").RunType<UInt32>;

package/dist/cjs/formats/numberFormats.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uint32 = exports.uint16 = exports.uint8 = exports.int32 = exports.int16 = exports.int8 = exports.negativeInt = exports.positiveInt = exports.negative = exports.positive = exports.float = exports.integer = void 0;
+const builderCore_ts_1 = require("../runtypes/builderCore.js");
+exports.integer = (0, builderCore_ts_1.presetBuilder)('number');
+exports.float = (0, builderCore_ts_1.presetBuilder)('number');
+exports.positive = (0, builderCore_ts_1.presetBuilder)('number');
+exports.negative = (0, builderCore_ts_1.presetBuilder)('number');
+exports.positiveInt = (0, builderCore_ts_1.presetBuilder)('number');
+exports.negativeInt = (0, builderCore_ts_1.presetBuilder)('number');
+exports.int8 = (0, builderCore_ts_1.presetBuilder)('number');
+exports.int16 = (0, builderCore_ts_1.presetBuilder)('number');
+exports.int32 = (0, builderCore_ts_1.presetBuilder)('number');
+exports.uint8 = (0, builderCore_ts_1.presetBuilder)('number');
+exports.uint16 = (0, builderCore_ts_1.presetBuilder)('number');
+exports.uint32 = (0, builderCore_ts_1.presetBuilder)('number');

package/dist/cjs/formats/refineFormat.d.ts

@@ -0,0 +1,24 @@
+import type { FormatNameOf, FormatParamsOf, TypeFormat, TypeFormatBase } from '../runtypes/typeFormat.ts';
+import type { Mutable } from '../runtypes/types.ts';
+import type { IPParams, StringParams } from './string/stringFormats.ts';
+import type { NumberParams } from '../formats/numberFormats.ts';
+import type { BigIntParams } from '../formats/bigintFormats.ts';
+import type { NativeDateParams } from './datetime/dateFormats.ts';
+import type { DateParams, DateTimeParams, TimeParams } from './datetime/stringDateTimeFormats.ts';
+type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+export interface RefinableParamsByFamily {
+    stringFormat: Partial<StringParams>;
+    numberFormat: Partial<NumberParams>;
+    bigintFormat: Partial<BigIntParams>;
+    nativeDate: Partial<NativeDateParams>;
+    date: Partial<DateParams>;
+    time: Partial<TimeParams>;
+    dateTime: Partial<DateTimeParams>;
+    ip: Partial<IPParams>;
+}
+export type RefinableParamsOf<T> = FormatNameOf<T> extends keyof RefinableParamsByFamily ? RefinableParamsByFamily[FormatNameOf<T>] : never;
+export type FormatBaseOf<T> = Extract<T extends string ? string : T extends number ? number : T extends bigint ? bigint : T extends globalThis.Date ? globalThis.Date : never, TypeFormatBase>;
+export type MergeFormat<T, P> = TypeFormat<FormatBaseOf<T>, FormatNameOf<T>, Prettify<Omit<FormatParamsOf<T>, keyof Mutable<P>> & Mutable<P>>>;
+export {};

package/dist/cjs/formats/refineFormat.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/formats/scalars.d.ts

@@ -0,0 +1,32 @@
+import { brand } from '../runtypes/builderCore.ts';
+import type { RunType } from '../runtypes/types.ts';
+import type { InjectRunTypeId, CompTimeArgs } from '../markers.ts';
+import type { LeafType, BrandArg, ExactParams } from '../runtypes/builderTypes.ts';
+import type { StringParamsValueFirst } from './string/stringFormats.ts';
+import type { NumberParams, Currency } from './numberFormats.ts';
+import type { BigIntParams } from './bigintFormats.ts';
+import type { NativeDateParams } from './datetime/dateFormats.ts';
+export { brand };
+export declare function string(id?: InjectRunTypeId<string>): RunType<string>;
+export declare function string<const P extends StringParamsValueFirst>(formatParams: CompTimeArgs<ExactParams<P, StringParamsValueFirst>>, id?: InjectRunTypeId<LeafType<'stringFormat', P>>): RunType<LeafType<'stringFormat', P>>;
+export declare function string<const P extends StringParamsValueFirst, const B extends string>(formatParams: CompTimeArgs<ExactParams<P, StringParamsValueFirst>>, brandTag: BrandArg<B>, id?: InjectRunTypeId<LeafType<'stringFormat', P, B>>): RunType<LeafType<'stringFormat', P, B>>;
+export declare function number(id?: InjectRunTypeId<number>): RunType<number>;
+export declare function number<const P extends NumberParams>(formatParams: CompTimeArgs<ExactParams<P, NumberParams>>, id?: InjectRunTypeId<LeafType<'numberFormat', P>>): RunType<LeafType<'numberFormat', P>>;
+export declare function number<const P extends NumberParams, const B extends string>(formatParams: CompTimeArgs<ExactParams<P, NumberParams>>, brandTag: BrandArg<B>, id?: InjectRunTypeId<LeafType<'numberFormat', P, B>>): RunType<LeafType<'numberFormat', P, B>>;
+export declare function currency(id?: InjectRunTypeId<Currency>): RunType<Currency>;
+export declare function currency<const P extends NumberParams>(formatParams: CompTimeArgs<ExactParams<P, NumberParams>>, id?: InjectRunTypeId<LeafType<'numberFormat', P & {
+    isCurrency: true;
+}>>): RunType<LeafType<'numberFormat', P & {
+    isCurrency: true;
+}>>;
+export declare function currency<const P extends NumberParams, const B extends string>(formatParams: CompTimeArgs<ExactParams<P, NumberParams>>, brandTag: BrandArg<B>, id?: InjectRunTypeId<LeafType<'numberFormat', P & {
+    isCurrency: true;
+}, B>>): RunType<LeafType<'numberFormat', P & {
+    isCurrency: true;
+}, B>>;
+export declare function bigInt(id?: InjectRunTypeId<bigint>): RunType<bigint>;
+export declare function bigInt<const P extends BigIntParams>(formatParams: CompTimeArgs<ExactParams<P, BigIntParams>>, id?: InjectRunTypeId<LeafType<'bigintFormat', P>>): RunType<LeafType<'bigintFormat', P>>;
+export declare function bigInt<const P extends BigIntParams, const B extends string>(formatParams: CompTimeArgs<ExactParams<P, BigIntParams>>, brandTag: BrandArg<B>, id?: InjectRunTypeId<LeafType<'bigintFormat', P, B>>): RunType<LeafType<'bigintFormat', P, B>>;
+export declare function date(id?: InjectRunTypeId<Date>): RunType<Date>;
+export declare function date<const P extends NativeDateParams>(formatParams: CompTimeArgs<ExactParams<P, NativeDateParams>>, id?: InjectRunTypeId<LeafType<'nativeDate', P>>): RunType<LeafType<'nativeDate', P>>;
+export declare function date<const P extends NativeDateParams, const B extends string>(formatParams: CompTimeArgs<ExactParams<P, NativeDateParams>>, brandTag: BrandArg<B>, id?: InjectRunTypeId<LeafType<'nativeDate', P, B>>): RunType<LeafType<'nativeDate', P, B>>;

package/dist/cjs/formats/scalars.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.brand = void 0;
+exports.string = string;
+exports.number = number;
+exports.currency = currency;
+exports.bigInt = bigInt;
+exports.date = date;
+const builderCore_ts_1 = require("../runtypes/builderCore.js");
+Object.defineProperty(exports, "brand", { enumerable: true, get: function () { return builderCore_ts_1.brand; } });
+function string(formatParamsOrId, brandOrId, id) {
+    const formatParams = typeof formatParamsOrId === 'object' ? formatParamsOrId : {};
+    return (0, builderCore_ts_1.builderResult)((0, builderCore_ts_1.lastInjectedId)(formatParamsOrId, brandOrId, id), { type: 'string', formatParams });
+}
+function number(formatParamsOrId, brandOrId, id) {
+    const formatParams = typeof formatParamsOrId === 'object' ? formatParamsOrId : {};
+    return (0, builderCore_ts_1.builderResult)((0, builderCore_ts_1.lastInjectedId)(formatParamsOrId, brandOrId, id), { type: 'number', formatParams });
+}
+function currency(formatParamsOrId, brandOrId, id) {
+    const formatParams = typeof formatParamsOrId === 'object' ? { ...formatParamsOrId, isCurrency: true } : { isCurrency: true };
+    return (0, builderCore_ts_1.builderResult)((0, builderCore_ts_1.lastInjectedId)(formatParamsOrId, brandOrId, id), { type: 'number', formatParams });
+}
+function bigInt(formatParamsOrId, brandOrId, id) {
+    const formatParams = typeof formatParamsOrId === 'object' ? formatParamsOrId : {};
+    return (0, builderCore_ts_1.builderResult)((0, builderCore_ts_1.lastInjectedId)(formatParamsOrId, brandOrId, id), { type: 'bigint', formatParams });
+}
+function date(formatParamsOrId, brandOrId, id) {
+    const formatParams = typeof formatParamsOrId === 'object' ? formatParamsOrId : {};
+    return (0, builderCore_ts_1.builderResult)((0, builderCore_ts_1.lastInjectedId)(formatParamsOrId, brandOrId, id), { type: 'date', formatParams });
+}

package/dist/cjs/formats/string/credit-card-pure-fns.d.ts

@@ -0,0 +1,26 @@
+import { type CreditCardTransformParams, type Override, type PresetFormat } from './stringFormats.ts';
+export declare const CARD_NETWORKS: readonly ["visa", "mastercard", "amex", "discover", "jcb", "diners", "unionpay", "maestro"];
+export type CardNetwork = (typeof CARD_NETWORKS)[number];
+export type CreditCardErrorType = 'format' | 'checksum' | 'network';
+export interface CreditCardParams {
+    networks?: readonly CardNetwork[];
+    separators?: string;
+    transform?: CreditCardTransformParams;
+}
+type DEFAULT_CREDIT_CARD_PARAMS = {
+    separators: ' -';
+};
+export type CreditCard<P extends Override<CreditCardParams> = {}> = PresetFormat<'creditCard', DEFAULT_CREDIT_CARD_PARAMS, P>;
+export declare const creditCard: import("./stringFormats.ts").PresetFormatBuilder<"creditCard", DEFAULT_CREDIT_CARD_PARAMS, Override<CreditCardParams>>;
+export interface CardNetworkRule {
+    prefixes: readonly (readonly [string, string])[];
+    lengths: readonly number[];
+}
+export type CardNetworkRules = Readonly<Record<string, CardNetworkRule>>;
+export declare const luhnSum: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_VJiknJ2exR2oMF">;
+export declare const isCreditCard: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_18wDCH5CXZoQKV">;
+export declare const cardNetworkRules: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_nsU8QeJCuCF8Kr">;
+export declare const matchesCardNetwork: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_A3KjzpjelkcBST">;
+export declare function getCardNetworkRules(): CardNetworkRules;
+export declare function luhnCheckDigit(body: string): string;
+export {};

package/dist/cjs/formats/string/credit-card-pure-fns.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesCardNetwork = exports.cardNetworkRules = exports.isCreditCard = exports.luhnSum = exports.creditCard = exports.CARD_NETWORKS = void 0;
+exports.getCardNetworkRules = getCardNetworkRules;
+exports.luhnCheckDigit = luhnCheckDigit;
+const pureFn_ts_1 = require("../../runtypes/pureFn.js");
+const pure_fn_ids_generated_ts_1 = require("../../runtypes/pure-fn-ids.generated.js");
+const rtUtils_ts_1 = require("../../runtypes/rtUtils.js");
+const stringFormats_ts_1 = require("./stringFormats.js");
+exports.CARD_NETWORKS = ['visa', 'mastercard', 'amex', 'discover', 'jcb', 'diners', 'unionpay', 'maestro'];
+exports.creditCard = (0, stringFormats_ts_1.presetFormatBuilder)('creditCard');
+exports.luhnSum = (0, pureFn_ts_1.registerPureFnFactory)(function () {
+    return function _luhn_sum(value) {
+        let sum = 0;
+        let double = false;
+        for (let i = value.length - 1; i >= 0; i--) {
+            const charCode = value.charCodeAt(i);
+            if (charCode < 48 || charCode > 57)
+                continue;
+            let digit = charCode - 48;
+            if (double) {
+                digit *= 2;
+                if (digit > 9)
+                    digit -= 9;
+            }
+            sum += digit;
+            double = !double;
+        }
+        return sum;
+    };
+}, pure_fn_ids_generated_ts_1.luhnSumId);
+exports.isCreditCard = (0, pureFn_ts_1.registerPureFnFactory)(function (utl) {
+    const luhnSumFn = utl.getPureFn(exports.luhnSum);
+    return function _is_credit_card(value, params) {
+        if (typeof value !== 'string' || value === '')
+            return 'format';
+        const separators = params.separators;
+        let count = 0;
+        let expectDigit = true;
+        for (let i = value.length - 1; i >= 0; i--) {
+            const charCode = value.charCodeAt(i);
+            if (charCode >= 48 && charCode <= 57) {
+                count++;
+                expectDigit = false;
+                continue;
+            }
+            if (expectDigit)
+                return 'format';
+            if (separators === undefined || separators.indexOf(value[i]) === -1)
+                return 'format';
+            expectDigit = true;
+        }
+        if (expectDigit)
+            return 'format';
+        if (count < 12 || count > 19)
+            return 'format';
+        return luhnSumFn(value) % 10 === 0 ? '' : 'checksum';
+    };
+}, pure_fn_ids_generated_ts_1.isCreditCardId);
+exports.cardNetworkRules = (0, pureFn_ts_1.registerPureFnFactory)(function () {
+    const RULES = {
+        visa: { prefixes: [['4', '4']], lengths: [13, 16, 19] },
+        mastercard: {
+            prefixes: [
+                ['51', '55'],
+                ['2221', '2720'],
+            ],
+            lengths: [16],
+        },
+        amex: {
+            prefixes: [
+                ['34', '34'],
+                ['37', '37'],
+            ],
+            lengths: [15],
+        },
+        discover: {
+            prefixes: [
+                ['6011', '6011'],
+                ['644', '649'],
+                ['65', '65'],
+                ['622126', '622925'],
+            ],
+            lengths: [16, 19],
+        },
+        jcb: { prefixes: [['3528', '3589']], lengths: [16, 17, 18, 19] },
+        diners: {
+            prefixes: [
+                ['300', '305'],
+                ['3095', '3095'],
+                ['36', '36'],
+                ['38', '39'],
+            ],
+            lengths: [14, 15, 16, 17, 18, 19],
+        },
+        unionpay: { prefixes: [['62', '62']], lengths: [16, 17, 18, 19] },
+        maestro: {
+            prefixes: [
+                ['5018', '5018'],
+                ['5020', '5020'],
+                ['5038', '5038'],
+                ['5893', '5893'],
+                ['6304', '6304'],
+                ['6759', '6759'],
+                ['6761', '6763'],
+            ],
+            lengths: [12, 13, 14, 15, 16, 17, 18, 19],
+        },
+    };
+    Object.freeze(RULES);
+    return function _card_network_rules() {
+        return RULES;
+    };
+}, pure_fn_ids_generated_ts_1.cardNetworkRulesId);
+exports.matchesCardNetwork = (0, pureFn_ts_1.registerPureFnFactory)(function (utl) {
+    const NETWORK_RULES = utl.getPureFn(exports.cardNetworkRules)();
+    return function _matches_card_network(value, params) {
+        const networks = params.networks;
+        if (networks === undefined || networks.length === 0)
+            return false;
+        const separators = params.separators;
+        let digits = value;
+        if (separators !== undefined) {
+            digits = '';
+            for (let i = 0; i < value.length; i++) {
+                if (separators.indexOf(value[i]) === -1)
+                    digits += value[i];
+            }
+        }
+        for (const network of networks) {
+            const rule = NETWORK_RULES[network];
+            if (rule === undefined)
+                continue;
+            if (rule.lengths.indexOf(digits.length) === -1)
+                continue;
+            for (const [low, high] of rule.prefixes) {
+                const head = digits.slice(0, low.length);
+                if (head >= low && head <= high)
+                    return true;
+            }
+        }
+        return false;
+    };
+}, pure_fn_ids_generated_ts_1.matchesCardNetworkId);
+function getCardNetworkRules() {
+    return (0, rtUtils_ts_1.getRTUtils)().getPureFn(exports.cardNetworkRules)();
+}
+function luhnCheckDigit(body) {
+    const luhnSumFn = (0, rtUtils_ts_1.getRTUtils)().getPureFn(exports.luhnSum);
+    return String((10 - (luhnSumFn(body + '0') % 10)) % 10);
+}

package/dist/cjs/formats/string/string-formats-pure-fns.d.ts

@@ -0,0 +1,12 @@
+export declare const isUUID: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_AgOXcprpjsrTKk">;
+export declare const codePointLength: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_Z2sc5xQPKB0oav">;
+export declare const isEcmaRegex: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_Qd_9GJQlOCVqDe">;
+export declare const punycodeDecode: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_GA20s6bj41GC1A">;
+export declare const punycodeEncode: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_5oCqd7YyfA9rEw">;
+export declare const isIdnaLabel: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_E29ul2pUOyD_Ay">;
+export declare const satisfiesBidi: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_vLId7t0J8HNWlN">;
+export declare const isIdnHostname: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_rgWveqNi_HeFF8">;
+export declare const isEmailAddress: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_LqTR2O-h6MYq9J">;
+export declare const isLocalHost: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_EG8OkOOSnT9bZn">;
+export declare const isIPV4: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf__3Pmrr5aNmyNi4">;
+export declare const isIPV6: import("../../runtypes/pureFn.ts").PureFnId<"@mionjs/run-types#pf_ndkQPoji6DFHx2">;