@ark/util - npm Package Compare versions

Comparing version 0.49.0 to 0.50.0

out/arrays.d.ts

@@ -23,12 +23,21 @@ import type { GuardablePredicate } from "./functions.ts";
 export type array<t = unknown> = readonly t[];
+export declare namespace array {
+    type multiply<t extends array, count extends number> = _multiply<t, [
+    ], count, [
+    ]>;
+    type _multiply<base extends array, result extends array, count extends number, i extends 1[]> = i["length"] extends count ? result : _multiply<base, [...result, ...base], count, [...i, 1]>;
+    type repeat<element, count extends number> = buildFromSegments<element, [
+    ], exponentials.max<count>, count>;
+    type buildFromSegments<element, result extends 1[], segments extends 1[][], count extends number, next extends 1[] = [...result, ...segments[0]]> = next["length"] extends count ? {
+        [i in keyof next]: element;
+    } : `${count}` extends keyof next ? buildFromSegments<element, result, nextSegments<segments>, count> : buildFromSegments<element, next, nextSegments<segments>, count>;
+    type nextSegments<segments extends 1[][]> = segments extends [unknown, ...infer nextSegments extends 1[][]] ? nextSegments : never;
+    type minLength<element, minLength extends number> = readonly [
+        ...multiply<[element], minLength>,
+        ...element[]
+    ];
+}
 export type listable<t> = t | readonly t[];
 export type flattenListable<t> = t extends array<infer element> ? element : t;
-export type minLengthArray<t, minLength extends number> = readonly [
-    ...repeat<[t], minLength>,
-    ...t[]
-];
-export type repeat<t extends array, count extends number> = _repeat<t, [
-], count, [
-]>;
-type _repeat<base extends array, result extends array, maxDepth extends number, depth extends 1[]> = depth["length"] extends maxDepth ? result : _repeat<base, [...result, ...base], maxDepth, [...depth, 1]>;
+export type longerThan<t extends array, n extends number> = `${n}` extends keyof t ? true : false;
 export type CollapsingList<t = unknown> = readonly [] | t | readonly [t, t, ...t[]];
@@ -102,2 +111,58 @@ export type headOf<t extends array> = t[0];
 ] : [expectedKey] extends [never] ? [] : [expectedKey];
+export type applyElementLabels<t extends readonly unknown[], labels extends readonly unknown[]> = labels extends [unknown, ...infer labelsTail] ? t extends readonly [infer head, ...infer tail] ? readonly [
+    ...labelElement<head, labels>,
+    ...applyElementLabels<tail, labelsTail>
+] : applyOptionalElementLabels<Required<t>, labels> : t;
+type applyOptionalElementLabels<t extends readonly unknown[], labels extends readonly unknown[]> = labels extends readonly [unknown, ...infer labelsTail] ? t extends readonly [infer head, ...infer tail] ? [
+    ...labelOptionalElement<head, labels>,
+    ...applyOptionalElementLabels<tail, labelsTail>
+] : applyRestElementLabels<t, labels> : t;
+type applyRestElementLabels<t extends readonly unknown[], labels extends readonly unknown[]> = t extends readonly [] ? [] : labels extends readonly [unknown, ...infer tail] ? [
+    ...labelOptionalElement<t[0], labels>,
+    ...applyRestElementLabels<t, tail>
+] : t;
+type labelElement<element, labels extends readonly unknown[]> = labels extends readonly [unknown] ? {
+    [K in keyof labels]: element;
+} : labels extends readonly [...infer head, unknown] ? labelElement<element, head> : [_: element];
+type labelOptionalElement<element, label extends readonly unknown[]> = label extends readonly [unknown] ? {
+    [K in keyof label]?: element;
+} : label extends readonly [...infer head, unknown] ? labelOptionalElement<element, head> : [_?: element];
+export type setIndex<arr extends readonly unknown[], i extends number, to extends arr[number]> = arr extends arr[number][] ? _setIndex<arr, i, to, []> : Readonly<_setIndex<arr, i, to, []>>;
+type _setIndex<arr extends readonly unknown[], i extends number, to extends arr[number], result extends arr[number][]> = arr extends readonly [infer head, ...infer tail] ? _setIndex<tail, i, to, [...result, result["length"] extends i ? to : head]> : result;
+type zero = [];
+type one = [1];
+type two = [1, 1];
+type three = [...two, ...two];
+type four = [...three, ...three];
+type five = [...four, ...four];
+type six = [...five, ...five];
+type seven = [...six, ...six];
+type eight = [...seven, ...seven];
+type nine = [...eight, ...eight];
+type ten = [...nine, ...nine];
+type eleven = [...ten, ...ten];
+type twelve = [...eleven, ...eleven];
+type thirteen = [...twelve, ...twelve];
+type fourteen = [...thirteen, ...thirteen];
+type exponentials = [
+    fourteen,
+    thirteen,
+    twelve,
+    eleven,
+    ten,
+    nine,
+    eight,
+    seven,
+    six,
+    five,
+    four,
+    three,
+    two,
+    one,
+    zero
+];
+declare namespace exponentials {
+    type max<n extends number> = _max<n, exponentials>;
+    type _max<n extends number, filtered extends unknown[]> = `${n}` extends keyof filtered[0] ? _max<n, tailOf<filtered>> : filtered;
+}
 export {};

out/errors.d.ts

 import type { brand } from "./generics.ts";
+import type { CastableBase } from "./records.ts";
 export declare class InternalArktypeError extends Error {
@@ -20,16 +21,10 @@ }
 export type noSuggest<s extends string = string> = ` ${s}`;
-/** "Hair Space" character, used  as a non-rendered sentinel for an error message string:
- *  https://www.compart.com/en/unicode/U+200A
- */
-export declare const zeroWidthSpace = "\u200A";
-/** "Hair Space" character, used  as a non-rendered sentinel for an error message string:
- *  https://www.compart.com/en/unicode/U+200A
- */
-export type ZeroWidthSpace = typeof zeroWidthSpace;
+/** Unrendered character (U+200B) used to mark a string type */
+export declare const ZeroWidthSpace = "\u200B";
+/** Unrendered character (U+200B) used to mark a string type */
+export type ZeroWidthSpace = typeof ZeroWidthSpace;
 export type ErrorMessage<message extends string = string> = `${message}${ZeroWidthSpace}`;
-export interface ErrorType<message extends string = string, ctx extends {} = {}> {
+export interface ErrorType<ctx extends {} = {}> extends CastableBase<ctx> {
     [brand]: "ErrorType";
-    message: message;
-    ctx: ctx;
 }
 export type Completion<text extends string = string> = `${text}${ZeroWidthSpace}${ZeroWidthSpace}`;

out/errors.js

@@ -16,5 +16,3 @@ export class InternalArktypeError extends Error {
 export const noSuggest = (s) => ` ${s}`;
-/** "Hair Space" character, used  as a non-rendered sentinel for an error message string:
- *  https://www.compart.com/en/unicode/U+200A
- */
-export const zeroWidthSpace = " ";
+/** Unrendered character (U+200B) used to mark a string type */
+export const ZeroWidthSpace = "\u{200B}";

out/generics.d.ts

@@ -13,2 +13,3 @@ import type { Primitive } from "./domain.ts";
 } & unknown;
+export type get<t, k extends PropertyKey> = t[k & keyof t];
 export type exact<t extends object, u extends object> = {
@@ -15,0 +16,0 @@ [k in keyof t]: k extends keyof u ? conform<t[k], u[k]> : never;

out/records.d.ts

@@ -86,11 +86,3 @@ import type { array } from "./arrays.ts";
 export type optionalKeyOf<o> = Exclude<keyof o, requiredKeyOf<o>>;
-export type merge<base, props> = base extends unknown ? props extends unknown ? show<omit<base, keyof props & keyof base> & props> : never : never;
-export type mergeExact<base, props> = base extends unknown ? props extends unknown ? show<omitMerged<base, props> & props> : never : never;
-type omitMerged<base, props> = {
-    [k in keyof base as excludeExactKeyOf<k, props>]: base[k];
-};
-type excludeExactKeyOf<key extends PropertyKey, o> = Exclude<key, extractExactKeyOf<key, o>>;
-type extractExactKeyOf<key extends PropertyKey, base> = keyof {
-    [k in keyof base as [key, k] extends [k, key] ? key : never]: 1;
-};
+export type merge<base, props> = base extends unknown ? props extends unknown ? keyof base & keyof props extends never ? show<base & props> : show<omit<base, keyof props & keyof base> & props> : never : never;
 export type override<base, merged extends {
@@ -162,3 +154,3 @@ [k in keyof base]?: unknown;
 export declare const invert: <t extends Record<PropertyKey, PropertyKey>>(t: t) => invert<t>;
-export declare const unset: " represents an uninitialized value";
+export declare const unset: " unset​";
 export type unset = typeof unset;
@@ -165,0 +157,0 @@ /**

out/records.js

@@ -1,2 +0,2 @@
-import { noSuggest } from "./errors.js";
+import { noSuggest, ZeroWidthSpace } from "./errors.js";
 import { flatMorph } from "./flatMorph.js";
@@ -58,3 +58,3 @@ /**
 export const invert = (t) => flatMorph(t, (k, v) => [v, k]);
-export const unset = noSuggest("represents an uninitialized value");
+export const unset = noSuggest(`unset${ZeroWidthSpace}`);
 export const enumValues = (tsEnum) => Object.values(tsEnum).filter(v => {
@@ -61,0 +61,0 @@ if (typeof v === "number")

out/registry.d.ts

@@ -1,2 +0,2 @@
-export declare const arkUtilVersion = "0.49.0";
+export declare const arkUtilVersion = "0.50.0";
 export declare const initialRegistryContents: {
@@ -3,0 +3,0 @@ version: string;

out/registry.js

@@ -9,3 +9,3 @@ import { domainOf } from "./domain.js";
 // For now, we assert this matches the package.json version via a unit test.
-export const arkUtilVersion = "0.49.0";
+export const arkUtilVersion = "0.50.0";
 export const initialRegistryContents = {
@@ -12,0 +12,0 @@ version: arkUtilVersion,

out/scanner.d.ts

 import type { KeySet } from "./records.ts";
+import { Backslash, type WhitespaceChar } from "./strings.ts";
 export declare class Scanner<lookahead extends string = string> {
@@ -13,2 +14,3 @@ chars: string[];
     shiftUntil(condition: Scanner.UntilCondition): string;
+    shiftUntilEscapable(condition: Scanner.UntilCondition): string;
     shiftUntilLookahead(charOrSet: string | KeySet): string;
@@ -27,2 +29,18 @@ shiftUntilNonWhitespace(): string;
     type UntilCondition = (scanner: Scanner, shifted: string) => boolean;
+    type shift<lookahead extends string, unscanned extends string> = `${lookahead}${unscanned}`;
+    type shiftUntil<unscanned extends string, terminator extends string, appendTo extends string = ""> = unscanned extends shift<infer lookahead, infer nextUnscanned> ? lookahead extends terminator ? [
+        appendTo,
+        unscanned
+    ] : shiftUntil<nextUnscanned, terminator, `${appendTo}${lookahead}`> : [appendTo, ""];
+    type shiftUntilEscapable<unscanned extends string, terminator extends string, escapeEscape extends Backslash | "", appendTo extends string = ""> = unscanned extends shift<infer lookahead, infer nextUnscanned> ? lookahead extends terminator ? [appendTo, unscanned] : lookahead extends Backslash ? nextUnscanned extends (shift<infer nextLookahead, infer postEscapedUnscanned>) ? shiftUntilEscapable<postEscapedUnscanned, terminator, escapeEscape, `${appendTo}${nextLookahead extends terminator ? "" : nextLookahead extends Backslash ? escapeEscape : Backslash}${nextLookahead}`> : [`${appendTo}${Backslash}`, ""] : shiftUntilEscapable<nextUnscanned, terminator, escapeEscape, `${appendTo}${lookahead}`> : [appendTo, ""];
+    type shiftUntilNot<unscanned extends string, nonTerminator extends string, appendTo extends string = ""> = unscanned extends shift<infer lookahead, infer nextUnscanned> ? lookahead extends nonTerminator ? shiftUntilNot<nextUnscanned, nonTerminator, `${appendTo}${lookahead}`> : [appendTo, unscanned] : [appendTo, ""];
+    type skipWhitespace<unscanned extends string> = shiftUntilNot<unscanned, WhitespaceChar>[1];
+    type shiftResult<scanned extends string, unscanned extends string> = [
+        scanned,
+        unscanned
+    ];
 }
+export declare const writeUnmatchedGroupCloseMessage: <char extends string, unscanned extends string>(char: char, unscanned: unscanned) => writeUnmatchedGroupCloseMessage<char, unscanned>;
+export type writeUnmatchedGroupCloseMessage<char extends string, unscanned extends string> = `Unmatched ${char}${unscanned extends "" ? "" : ` before ${unscanned}`}`;
+export declare const writeUnclosedGroupMessage: <missingChar extends string>(missingChar: missingChar) => writeUnclosedGroupMessage<missingChar>;
+export type writeUnclosedGroupMessage<missingChar extends string> = `Missing ${missingChar}`;

out/scanner.js

@@ -1,2 +0,2 @@
-import { escapeChar, whitespaceChars } from "./strings.js";
+import { Backslash, whitespaceChars } from "./strings.js";
 export class Scanner {
@@ -27,9 +27,25 @@ chars;
         while (this.lookahead) {
-            if (condition(this, shifted)) {
-                if (shifted[shifted.length - 1] === escapeChar)
-                    shifted = shifted.slice(0, -1);
+            if (condition(this, shifted))
+                break;
+            else
+                shifted += this.shift();
+        }
+        return shifted;
+    }
+    shiftUntilEscapable(condition) {
+        let shifted = "";
+        while (this.lookahead) {
+            if (this.lookahead === Backslash) {
+                this.shift();
+                if (condition(this, shifted))
+                    shifted += this.shift();
+                else if (this.lookahead === Backslash)
+                    shifted += this.shift();
                 else
-                    break;
+                    shifted += `${Backslash}${this.shift()}`;
             }
-            shifted += this.shift();
+            else if (condition(this, shifted))
+                break;
+            else
+                shifted += this.shift();
         }
@@ -71,1 +87,3 @@ return shifted;
 }
+export const writeUnmatchedGroupCloseMessage = (char, unscanned) => `Unmatched ${char}${(unscanned === "" ? "" : ` before ${unscanned}`)}`;
+export const writeUnclosedGroupMessage = (missingChar) => `Missing ${missingChar}`;

out/strings.d.ts

@@ -7,2 +7,3 @@ export declare const capitalize: <s extends string>(s: s) => Capitalize<s>;
 export type charsBeforeLast<s extends string> = s extends `${infer head}${infer tail}` ? tail extends "" ? "" : `${head}${charsBeforeLast<tail>}` : "";
+export type contains<s extends string, sub extends string> = s extends `${string}${sub}${string}` ? true : false;
 export declare const anchoredRegex: (regex: RegExp | string) => RegExp;
@@ -16,4 +17,4 @@ export declare const deanchoredRegex: (regex: RegExp | string) => RegExp;
 };
-export declare const escapeChar = "\\";
-export type EscapeChar = typeof escapeChar;
+export declare const Backslash = "\\";
+export type Backslash = typeof Backslash;
 export declare const whitespaceChars: {
@@ -34,1 +35,2 @@ readonly " ": 1;
 export declare const emojiToUnicode: (emoji: string) => string;
+export declare const alphabet: readonly ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"];

out/strings.js

@@ -19,3 +19,3 @@ export const capitalize = (s) => (s[0].toUpperCase() + s.slice(1));
 };
-export const escapeChar = "\\";
+export const Backslash = "\\";
 export const whitespaceChars = {
@@ -33,1 +33,29 @@ " ": 1,
     .join("");
+export const alphabet = [
+    "a",
+    "b",
+    "c",
+    "d",
+    "e",
+    "f",
+    "g",
+    "h",
+    "i",
+    "j",
+    "k",
+    "l",
+    "m",
+    "n",
+    "o",
+    "p",
+    "q",
+    "r",
+    "s",
+    "t",
+    "u",
+    "v",
+    "w",
+    "x",
+    "y",
+    "z"
+];

package.json

 {
   "name": "@ark/util",
-  "version": "0.49.0",
+  "version": "0.50.0",
   "license": "MIT",
@@ -5,0 +5,0 @@ "author": {

tsconfig.base.json

 {
 	"compilerOptions": {
 		"module": "NodeNext",
-		"target": "ES2022",
+		"target": "ES2023",
 		"moduleResolution": "NodeNext",
@@ -16,5 +16,4 @@ "lib": ["ESNext"],
 		"exactOptionalPropertyTypes": true,
-		"forceConsistentCasingInFileNames": true,
-		"stripInternal": true
+		"forceConsistentCasingInFileNames": true
 	}
 }

No alert changes

Improved metrics

Total package byte prevSize

115009

6.11%

Lines of code

2504

4.99%

No dependency changes