@avstantso/ts 1.3.0 → 1.3.2

package/CHANGELOG.md

@@ -1,6 +1,20 @@
 # Changelog
 
 
+## [1.3.2] - 2026-02-05
+
+### Changed
+
+- +String.Split
+
+
+## [1.3.1] - 2026-02-04
+
+### Changed
+
+- Removed `dev-basic` workspace dependency (dev deps now resolved via `.yarnrc.yml` packageExtensions)
+
+
 ## [1.3.0] - 2026-01-31
 
 ### Changed

package/README.md

@@ -73,22 +73,189 @@ const flattened = TS.flat({ a: 1, b: { c: 2 } }); // { a: 1, c: 2 }
 
 The `@avstantso/ts` package provides a comprehensive suite of type-level utilities organized into the following namespaces:
 
-- [TS.Extends](#tsextends) - Type extension checking
-- [TS.Increment / TS.Decrement](#tsincrement--tsdecrement) - Numeric type arithmetic
-- [TS.Func](#tsfunc) - Function type utilities
-- [TS.Union](#tsunion) - Union type manipulation
-- [TS.Array](#tsarray) - Array type utilities
-- [TS.ASCII](#tsascii) - ASCII character types and maps
-- [TS.Comparisons](#tscomparisons) - Type-level comparisons
-- [TS.String](#tsstring) - String type manipulation
-- [TS.Structure](#tsstructure) - Object structure utilities
-  - [Object Constructor Extensions](#object-constructor-extensions) - Typed Object.keys/values/entries
-- [TS.Boolean](#tsboolean) - Boolean logic types
-- [TS.Numeric](#tsnumeric) - Numeric literal utilities
-- [TS.Literal](#tsliteral) - Type literal definitions
-- [TS.Type](#tstype) - Type manipulation utilities
-- [TS.Resolve](#tsresolve) - Type literal resolution
-- [TS Utility Types](#ts-utility-types) - Miscellaneous utility types
+- [TS.Extends](#tsextends) — Type extension checking
+- [TS.Increment / TS.Decrement](#tsincrement--tsdecrement) — Numeric type arithmetic
+  - [TS.ArrN / TS.ArrM](#tsarrn-and-tsarrm) — Array type constraints
+- [TS.Func](#tsfunc) — Function type utilities
+  - [TS.Func.Nested](#tsfuncnesteddepth-r-p) — Nested function type
+- [TS.Union](#tsunion) — Union type manipulation
+  - [TS.Union.ToIntersection](#tsuniontointersectionu) — Union → intersection
+  - [TS.Union.Pop](#tsunionpopu) — Pop last from union
+  - [TS.Union.ToTuple](#tsuniontotupleu) — Union → tuple
+  - [TS.Union.IsUnion](#tsunionisuniont-iftrue--true-iffalse--false) — Test if union
+- [TS.Array](#tsarray) — Array type utilities
+  - Creation
+    - [TS.Array.Create](#tsarraycreatel-item) — Create array of length
+    - [TS.Array.Create.Optional](#tsarraycreateoptionald-item) — Create optional array
+    - [TS.Array.Numbers](#tsarraynumbersl) — Numeric literals array
+    - [TS.Array.Letters](#tsarraylettersl) — Letters array
+  - Analysis
+    - [TS.Array.Length](#tsarraylength-tarr) — Array length
+    - [TS.Array.Length.IfExeeded](#tsarraylengthifexeededtarr-n-iftrue--true-iffalse--false) — Test length exceeded
+  - Search
+    - [TS.Array.IndexOf](#tsarrayindexoftarr-item-i--0) — Find index of item
+    - [TS.Array.IfHasItem](#tsarrayifhasitemtarr-item-iftrue--true-iffalse--false) — Test has item
+    - [TS.Array.IfEach](#tsarrayifeachtarr-item-iftrue--true-iffalse--false) — Test each item
+    - [TS.Array.CountOf](#tsarraycountoftarr-item) — Count matching items
+  - Transformation
+    - [TS.Array.AddUnique](#tsarrayadduniquetarr-item) — Add unique item
+    - [TS.Array.MergeUnique](#tsarraymergeuniquetarr1-tarr2) — Merge without duplicates
+    - [TS.Array.Filter](#tsarrayfiltertarr-tfilter--undefined) — Filter items
+    - [TS.Array.Filter.Unique](#tsarrayfilteruniquetarr) — Remove duplicates
+    - [TS.Array.Sub](#tsarraysubtarr-start-end) — Sub-array
+    - [TS.Array.Remove](#tsarrayremovetarr-start-end) — Remove section
+    - [TS.Array.Reverse](#tsarrayreversetarr) — Reverse array
+    - [TS.Array.Join](#tsarrayjointarr) — Join to string
+    - [TS.Array.Cast](#tsarraycasttarr-item--any) — Cast items to type
+  - Map / Record
+    - [TS.Array.ToKey](#tsarraytokeytarr) — Array → key union
+    - [TS.Array.ToKey2Key](#tsarraytokey2keytarr) — Key-to-key record
+    - [TS.Array.ToRecord](#tsarraytorecordtarr-t) — Array → record
+    - [TS.Array.KeyValueMapFrom](#tsarraykeyvaluemapfromkeys-firstvalue--0) — Key-value map
+    - [TS.Array.ValueKeyMapFrom](#tsarrayvaluekeymapfromkeys-firstvalue--0) — Value-key map
+  - Min / Max / Sort
+    - [TS.Array.Min](#tsarraymintarr) — Find minimum
+    - [TS.Array.Min.Index](#tsarrayminindextarr) — Find minimum index
+    - [TS.Array.Max](#tsarraymaxtarr) — Find maximum
+    - [TS.Array.Max.Index](#tsarraymaxindextarr) — Find maximum index
+    - [TS.Array.Sort](#tsarraysorttarr-asc--true) — Sort array
+    - [TS.Array.Sort.Pair](#tsarraysortpairk) — Pair for key-based sorting
+    - [TS.Array.Sort.Desc](#tsarraysortdesctarr) — Sort descending
+  - Runtime
+    - [TS.Array.ToKey2Key()](#tsarraytokey2keyaarr-a) — Create key-to-key record (runtime)
+- [TS.ASCII](#tsascii) — ASCII character types and maps
+  - Letters
+    - [TS.ASCII.Letters](#tsasciilettersisuppertrue) — Letter array by case
+    - [TS.ASCII.Letters.Upper](#tsasciilettersupper) / [.Lower](#tsasciiletterslower) — Upper/lowercase letter arrays
+    - [TS.ASCII.Letter](#tsasciiletter) — Letter union by case
+    - [TS.ASCII.Letter.Upper](#tsasciiletterupper) / [.Lower](#tsasciiletterlower) — Upper/lowercase letter unions
+  - Character Arrays
+    - [TS.ASCII](#tsascii-2) — All ASCII characters
+    - [TS.ASCII.Control](#tsasciicontrol) / [.Printable](#tsasciiprintable) / [.Extended](#tsasciiextended) — Character subsets
+  - Maps
+    - [TS.ASCII.Map](#tsasciimap) — Character → code map
+    - [TS.ASCII.Map.Control](#tsasciimapcontrol) / [.Printable](#tsasciimapprintable) / [.Extended](#tsasciimapextended) — Subset maps
+  - [TS.ASCII.Code](#tsasciicode) — Character → code lookup
+  - [TS.ASCII.Character](#tsasciicharacter) — All ASCII characters union
+- [TS.Comparisons](#tscomparisons) — Type-level comparisons
+  - [TS.Comparisons.LT](#tscomparisonslt) — Less than
+  - [TS.Comparisons.LTE](#tscomparisonslte) — Less than or equal
+  - [TS.Comparisons.GT](#tscomparisonsgt) — Greater than
+  - [TS.Comparisons.GTE](#tscomparisonsgte) — Greater than or equal
+- [TS.String](#tsstring) — String type manipulation
+  - [TS.String\<T, D\>](#tsstring-1) — Cast to string literal
+  - [TS.String.Possible](#tsstringpossible) — Convertible types
+  - [TS.String.Pattern](#tsstringpattern) — Regex pattern shortcuts
+  - Analysis
+    - [TS.String.Length](#tsstringlength) — String length
+    - [TS.String.IsLengthBetween](#tsstringislengthbetween) — Length in range
+    - [TS.String.SplitToChars](#tsstringsplittochars) — Split to characters
+    - [TS.String.Split](#tsstringsplits-separator) — Split by separator
+  - Manipulation
+    - [TS.String.Repeat](#tsstringrepeat) — Repeat N times
+    - [TS.String.Includes](#tsstringincludes) — Test includes pattern
+    - [TS.String.IndexOf](#tsstringindexof) — Find pattern index
+    - [TS.String.Replace](#tsstringreplace) — Replace matches
+    - [TS.String.Trim](#tsstringtrim) — Trim whitespace
+    - [TS.String.Trim.Start](#tsstringtrimstart) / [.End](#tsstringtrimend) — Trim start/end
+  - Case Conversion
+    - [TS.String.Case](#tsstringcasetype-s-r) — Generic case conversion
+    - [TS.String.Case.Camel](#tsstringcasecamels-r--removes) — camelCase
+    - [TS.String.Case.Pascal](#tsstringcasepascals-r--removes) — PascalCase
+    - [TS.String.Case.Snake](#tsstringcasesnakes-r--removes) — snake_case
+    - [TS.String.Case.Snake.Up](#tsstringcasesnakeups-r--removes) — UPPER_SNAKE_CASE
+    - [TS.String.Case.Kebab](#tsstringcasekebabs-r--removes) — kebab-case
+    - [TS.String.Case.Settings.Removes](#tsstringcasesettingsremoves) — Removal characters
+    - [TS.String.Case.Settings.Removes.Map](#tsstringcasesettingsremovesmap) — Extensible removal map
+- [TS.Structure](#tsstructure) — Object structure utilities
+  - Test
+    - [TS.Structure.IfStructure](#tsstructureifstructuret-iftrue--true-iffalse--false) — Test is structure
+    - [TS.Structure](#tsstructuret) — Structure constraint
+    - [TS.Structure.Wildcard](#tsstructurewildcard) / [.MapOfNotRules](#tsstructuremapofnotrules) / [.NotRules](#tsstructurenotrules) — Rules
+  - Conversion
+    - [TS.Structure.ToKeysArray](#tsstructuretokenysarrayo) — Keys tuple
+    - [TS.Structure.ToValuesArray](#tsstructuretovaluesarrayo) — Values tuple
+    - [TS.Structure.ToEntriesArray](#tsstructuretoentriesarrayo) — Entries tuple
+  - Manipulation
+    - [TS.Structure.Separate](#tsstructureseparatet) — Separate plain/structural
+    - [TS.Structure.Reverse](#tsstructurereverse) — Reverse to value-key map
+    - [TS.Structure.Split](#tsstructuresplito) — Split to single-field objects
+    - [TS.Structure.Combine](#tsstructurecombinea) — Combine objects
+  - Runtime
+    - [TS.Structure.is()](#tsstructureis) — Test is structure (runtime)
+    - [TS.Structure.keyByValue()](#tsstructurekeybyvalue) — Find key by value (runtime)
+    - [TS.Structure.reverse()](#tsstructurereverse-1) — Reverse structure (runtime)
+  - [Object Constructor Extensions](#object-constructor-extensions) — Typed Object.keys/values/entries
+    - [Object.keysEx](#objectkeyso)
+    - [Object.valuesEx](#objectvaluesexo)
+    - [Object.entriesEx](#objectentriesexo)
+- [TS.Boolean](#tsboolean) — Boolean logic types
+  - [TS.If](#tsifcondition-iftrue--true-iffalse--false) — Conditional
+  - [TS.If.And](#tsifandconditions-iftrue--true-iffalse--false) — Logical AND
+  - [TS.If.Or](#tsiforconditions-iftrue--true-iffalse--false) — Logical OR
+  - [TS.If.Xor](#tsifxorconditions-iftrue--true-iffalse--false) — Logical XOR
+- [TS.Numeric](#tsnumeric) — Numeric literal utilities
+  - Domain-Independent
+    - [TS.Numeric.IsPositive](#tsnumericispositive) / [.IsNegative](#tsnumericisnegative) — Sign tests
+    - [TS.Numeric.Positive.ToNegative](#tsnumericpositivetonegative) / [Numeric.Negative.ToPositive](#tsnumericnegativetopositive) — Sign conversion
+    - [TS.Numeric.Sign](#tsnumericsign) — Get sign
+    - [TS.Numeric.Digits](#tsnumericdigits) — Digit characters
+    - [TS.Numeric.Digits.Map](#tsnumericdigitsmap) / [.IsOdd](#tsnumericdigitsisodd) — Digit maps
+    - [TS.Numeric.Digits.Hex](#tsnumericdigitshex) / [.Hex.Map](#tsnumericdigitshexmap) — Hexadecimal digits
+    - [TS.Numeric.IsOdd](#tsnumericisodd) / [.IsEven](#tsnumericiseven) — Parity tests
+    - [TS.Numeric.IsNumber](#tsnumericisnumber) — String → number test
+    - [TS.Numeric.Parse](#tsnumericparse) — String → number literal
+  - Domain
+    - [TS.Numeric.Domain.Positive](#tsnumericdomainpositive) / [.Negative](#tsnumericdomainnegative) — Numeric ranges
+    - [TS.Numeric.Domain.Increment](#tsnumericdomainincrement) / [.Decrement](#tsnumericdomaindecrement) — Full-domain inc/dec
+  - Math
+    - [TS.Numeric.Abs](#tsnumericabsn) — Absolute value
+    - [TS.Numeric.Invert](#tsnumericinvertn) — Invert sign
+    - [TS.Numeric.Summ](#tsnumericsummx-y) — Addition
+    - [TS.Numeric.Diff](#tsnumericdiffx-y) — Subtraction
+    - [TS.Numeric.Multiply](#tsnumericmultiplyx-y) — Multiplication
+    - [TS.Numeric.Div](#tsnumericdivx-y) — Division
+    - [TS.Numeric.Power](#tsnumericpowerx-e) — Exponentiation
+- [TS.Literal](#tsliteral) — Type literal definitions
+  - [TS.Literal](#tsliteral-1) — Available literals union
+  - [TS.Literal.Map](#tsliteralmap) — Literal → type map
+  - [TS.Literal.NumberLike](#tsliteralnumberlike) / [.IsNumberLike](#tsliteralisnumberlike) — Number-like literals
+  - [TS.Literal.StringLike](#tsliteralstringlike) / [.IsStringLike](#tsliteralisstringlike) — String-like literals
+  - [TS.Literal.List](#tsliterallist) — Literals array
+  - [TS.Literal.Key2KeyRec](#tsliteralkey2keyrec) — Key-to-key record
+  - Runtime
+    - [TS.Literal.List](#tsliterallist-1) — Literals array (runtime)
+    - [TS.Literal.Empty()](#tsliteralemptytype) — Get empty value
+    - [TS.Literal.IsValue()](#tsliteralisvaluetype-value) — Type guard
+    - [TS.Literal._Register()](#tsliteral_registerliteral-empty) — Register custom literal
+- [TS.Type](#tstype) — Type manipulation utilities
+  - [TS.Type](#tstype-1) — Available types union
+  - [TS.Type.Not](#tstypenotfunction) — Exclude types
+  - [TS.Type.Def](#tstypedef) — Type definition structure
+  - [TS.Type.KeyDef](#tstypekeydef) — Keyed type definition
+  - [TS.Type.KLD](#tstypekld) — Key-literal-default array
+  - [TS.Type.Union](#tstypeunion) — Type union with literal
+  - Runtime
+    - [TS.Type.KeyDef()](#tstypekeydefkey-type) — Create keyed def (runtime)
+    - [TS.Type.KLD()](#tstypekldkey-type-def) — Create KLD (runtime)
+- [TS.Resolve](#tsresolve) — Type literal resolution
+- [TS Utility Types](#ts-utility-types) — Miscellaneous utility types
+  - [TS.Alt](#tsaltt) — Alternative fields
+  - [TS.Flat](#tsflatt-depth--1) — Flatten structure
+  - [TS.IfDef](#tsifdef) / [TS.IfDefKey](#tsifdefkey) — Defined selection
+  - [TS.Opaque](#tsopaquetypemeta-t) — Opaque/nominal types
+  - [TS.Options](#tsoptionstypemap-tdefaults) — Options with defaults
+  - Override
+    - [TS.Override](#tsoverridetbase-textended-toptional--false) — Override properties
+    - [TS.IfIsOverrided](#tsifisoverrided) / [.IfIsOverridedKey](#tsifisoverridedkey) — Test overridden
+    - [TS.IfNotOverrided](#tsifnotoverrided) / [.IfNotOverridedKey](#tsifnotoverridedkey) — Select if not overridden
+    - [TS.OverrideIfNot](#tsoverrideifnot) — Conditional override
+  - [TS.ReplaceKey](#tsreplacekey) / [TS.ReplaceKeyOpt](#tsreplacekeyopt) — Replace key type
+  - [TS.RequiredKeys](#tsrequiredkeys) / [TS.OptionalKeys](#tsoptionalkeys) — Key extraction
+  - [TS.Merge](#tsmerge) / [TS.Merge.Fields](#tsmergefields) — Type merging
+  - Runtime
+    - [TS.isKey()](#tsiskeyk-extends-avstandsotskey) — Key type guard
+    - [TS.flat()](#tsflatstructure-depth--1) — Flatten structure (runtime)
 
 ---
 
@@ -960,6 +1127,26 @@ type Single = TS.String.SplitToChars<'A'>; // ['A']
 type Multiple = TS.String.SplitToChars<'AB'>; // ['A', 'B']
 ```
 
+#### `TS.String.Split<S, Separator>`
+
+Split string literal into substrings array by `Separator`.
+
+**Type Parameters:**
+- `S` - String literal to split
+- `Separator` - ASCII character to split by
+
+**Returns:** Array of string literal substrings
+
+**Example:**
+```typescript
+import { TS } from '@avstantso/ts';
+
+type Empty = TS.String.Split<'', ASCII.Character>; // ['']
+type Pipe = TS.String.Split<'A|B', '|'>; // ['A', 'B']
+type NoMatch = TS.String.Split<'A|B', ','>; // ['A|B']
+type CSV = TS.String.Split<'First,Next', ','>; // ['First', 'Next']
+```
+
 ### String Manipulation Types
 
 #### `TS.String.Repeat<S, N>`

package/dist/_global/string.d.ts

@@ -97,6 +97,31 @@ declare namespace AVStantso.TS.String {
      * type l2 = CheckType<SplitToChars<'AB'>, ['A', 'B']>;
      */
     export type SplitToChars<S extends string> = S extends undefined ? S : _SplitToChars<S>;
+    /**
+     * @summary Split `string` literal to substrings array by `Separator`.\
+     * ⚠ Unsafe, internal
+     * @example
+     * type n = CheckType<_Split<never, never>, never>;
+     * type u = CheckType<_Split<undefined, never>, [undefined]>; // ⚠
+     * 
+     * type l0 = CheckType<_Split<'', ASCII.Character>, ['']>;
+     * type l1 = CheckType<_Split<'A|B', '|'>, ['A', 'B']>;
+     * type l2 = CheckType<_Split<'A|B', ','>, ['A|B']>;
+     * type l3 = CheckType<_Split<'First,Next', ','>, ['First', 'Next']>;
+     */
+    export type _Split<S extends string, Separator extends ASCII.Character, R extends string[] = []> = S extends `${infer C}${Separator}${infer E}` ? _Split<E, Separator, [...R, C]> : [...R, S];
+    /**
+     * @summary Split `string` literal to substrings array by `Separator`
+     * @example
+     * type n = CheckType<Split<never, never>, never>;
+     * type u = CheckType<Split<undefined, never>, []>;
+     * 
+     * type l0 = CheckType<Split<'', ASCII.Character>, ['']>;
+     * type l1 = CheckType<Split<'A|B', '|'>, ['A', 'B']>;
+     * type l2 = CheckType<Split<'A|B', ','>, ['A|B']>;
+     * type l3 = CheckType<Split<'First,Next', ','>, ['First', 'Next']>;
+     */
+    export type Split<S extends string, Separator extends ASCII.Character> = S extends undefined ? S : Separator extends undefined ? Separator : _Split<S, Separator>;
     type _Repeat<S extends Possible, N extends number, R extends string = ''> = N extends 0 ? R : _Repeat<S, Decrement<N>, `${R}${S}`>;
     /**
      * @summary Repeat string possible `S` by `N` times

package/package.json

@@ -2,7 +2,7 @@
   "name": "@avstantso/ts",
   "license": "MIT",
   "author": "avstantso",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "TypeScript helpers",
   "keywords": [
     "TypeScript"
@@ -27,11 +27,10 @@
     "test": "NODE_ENV=test jest --coverage"
   },
   "dependencies": {
-    "@avstantso/core": "1.2.1",
-    "@avstantso/std-ext": "1.2.1"
+    "@avstantso/core": "1.2.2",
+    "@avstantso/std-ext": "1.2.2"
   },
   "devDependencies": {
-    "@avstantso-shared/node-js--code-gen": "latest",
-    "@avstantso/dev-basic": "1.0.0"
+    "@avstantso-shared/node-js--code-gen": "latest"
   }
 }