Version 1.0.66 (#1490)

* StringGraphemeCount | Intl Segmentation | Accelerate

* Intl.Segmenter Polyfill

* ChangeLog

* Version

Author: sinclairzx81

changelog/1.0.0.md

@@ -3,6 +3,8 @@
 ---
 
 ### Version Updates
+- [Revision 1.0.66](https://github.com/sinclairzx81/typebox/pull/1490)
+  - String Length Grapheme Segmentation Polyfill for Intl.Segmenter 
 - [Revision 1.0.65](https://github.com/sinclairzx81/typebox/pull/1489)
   - Support Schema Inference for If, Then and Else Keywords
 - [Revision 1.0.64](https://github.com/sinclairzx81/typebox/pull/1487)

example/index.ts

@@ -1,5 +1,6 @@
 import { Compile } from 'typebox/compile'
 import System from 'typebox/system'
+import Guard from 'typebox/guard'
 import Format from 'typebox/format'
 import Schema from 'typebox/schema'
 import Value from 'typebox/value'

readme.md

@@ -25,12 +25,12 @@ $ npm install typebox
 
 ## Usage
 
-A TypeScript Engine for Json Schema [Reference](https://tsplay.dev/wQaoGw)
+A TypeScript engine for Json Schema [Reference](https://tsplay.dev/wOyMRm)
 
 ```typescript
 import Type from 'typebox'
 
-// Json Schema Builder
+// Json Schema
 
 const T = Type.Object({                             // const T = {
   x: Type.Number(),                                 //   type: 'object',
@@ -48,7 +48,7 @@ type T = Type.Static<typeof T>                      // type T = {
                                                     //   z: number
                                                     // }
 
-// TypeScript Engine
+// TypeScript
 
 const { S } = Type.Script({ T }, `
   type RenameKey<K> = 

src/guard/guard.ts

@@ -148,13 +148,6 @@ export function IsValueLike(value: unknown): value is bigint | boolean | null |
     IsUndefined(value)
 }
 // --------------------------------------------------------------------------
-// String
-// --------------------------------------------------------------------------
-/** Returns the number of Unicode Grapheme Clusters */
-export function StringGraphemeCount(value: string): number {
-  return Array.from(value).length
-}
-// --------------------------------------------------------------------------
 // Array
 // --------------------------------------------------------------------------
 export function Every<T>(value: T[], offset: number, callback: (value: T, index: number) => boolean): boolean {
@@ -217,3 +210,86 @@ export function IsDeepEqual(left: unknown, right: unknown): boolean {
     IsArray(left) ? DeepEqualArray(left, right) : IsObject(left) ? DeepEqualObject(left, right) : IsEqual(left, right)
   )
 }
+// --------------------------------------------------------------------------
+// StringGraphemeCountIntl - Intl.Segmenter Polyfill
+// --------------------------------------------------------------------------
+//
+// const segmenter = new Intl.Segmenter(undefined, { granularity: 'grapheme' })
+// function StringGraphemeCountIntl(value: string): number {
+//   const iterator = segmenter.segment(value)[Symbol.iterator]()
+//   let length = 0
+//   while (!iterator.next().done) length++
+//   return length
+// }
+//
+// --------------------------------------------------------------------------
+function IsRegionalIndicator(value: number): boolean {
+  return value >= 0x1F1E6 && value <= 0x1F1FF
+}
+function IsVariationSelector(value: number): boolean {
+  return value >= 0xFE00 && value <= 0xFE0F
+}
+function IsCombiningMark(value: number): boolean {
+  return (
+    (value >= 0x0300 && value <= 0x036F) ||
+    (value >= 0x1AB0 && value <= 0x1AFF) ||
+    (value >= 0x1DC0 && value <= 0x1DFF) ||
+    (value >= 0xFE20 && value <= 0xFE2F)
+  )
+}
+function CodePointLength(value: number) {
+  return value > 0xFFFF ? 2 : 1
+}
+function StringGraphemeCountIntl(value: string): number {
+  let count = 0
+  let index = 0
+  while (index < value.length) {
+    const start = value.codePointAt(index)!
+    let clusterEnd = index + CodePointLength(start)
+    // Combining marks & variation selectors
+    while (clusterEnd < value.length) {
+      const next = value.codePointAt(clusterEnd)!
+      if (IsCombiningMark(next) || IsVariationSelector(next)) {
+        clusterEnd += CodePointLength(next)
+      } else {
+        break
+      }
+    }
+    // ZWJ sequences
+    while (clusterEnd < value.length - 1 && value[clusterEnd] === '\u200D') {
+      const next = value.codePointAt(clusterEnd + 1)!
+      clusterEnd += 1 + CodePointLength(next)
+    }
+    // Regional indicator pairs (flags)
+    const first = IsRegionalIndicator(start)
+    const second = clusterEnd < value.length && IsRegionalIndicator(value.codePointAt(clusterEnd)!)
+    if (first && second) {
+      const next = value.codePointAt(clusterEnd)!
+      clusterEnd += CodePointLength(next)
+    }
+    count++
+    index = clusterEnd
+  }
+  return count
+}
+// --------------------------------------------------------------------------
+// StringGraphemeCount
+// --------------------------------------------------------------------------
+function IsComplexGraphemeCodeUnit(value: number): boolean {
+  return (
+    (value >= 0xD800 && value <= 0xDBFF) || // High surrogate
+    (value >= 0x0300 && value <= 0x036F) || // Combining diacritical marks
+    (value === 0x200D) // Zero-width joiner
+  )
+}
+/** Returns the number of Unicode Grapheme Clusters */
+export function StringGraphemeCount(value: string): number {
+  let count = 0
+  for (let index = 0; index < value.length; index++) {
+    if (IsComplexGraphemeCodeUnit(value.charCodeAt(index))) {
+      return StringGraphemeCountIntl(value)
+    }
+    count++
+  }
+  return count
+}

tasks.ts

@@ -8,7 +8,7 @@ import { Range } from './task/range/index.ts'
 import { Metrics } from './task/metrics/index.ts'
 import { Task } from 'tasksmith'
 
-const Version = '1.0.65'
+const Version = '1.0.66'
 
 // ------------------------------------------------------------------
 // Build

test/typebox/runtime/guard/guard.ts

@@ -324,3 +324,123 @@ Test('Should IsClassInstance 15', () => {
   const strObj = new String('abc')
   Assert.IsEqual(Guard.IsClassInstance(strObj), true)
 })
+// ------------------------------------------------------------------
+// Guard.StringGraphemeCount
+// ------------------------------------------------------------------
+Test('Should StringGraphemeCount 1', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount(''), 0)
+})
+Test('Should StringGraphemeCount 2', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('a'), 1)
+})
+Test('Should StringGraphemeCount 3', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('hello'), 5)
+})
+Test('Should StringGraphemeCount 4', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('a b c'), 5)
+})
+Test('Should StringGraphemeCount 5', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('!?.'), 3)
+})
+Test('Should StringGraphemeCount 6', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('é'), 1)
+})
+Test('Should StringGraphemeCount 7', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('éàè'), 3)
+})
+Test('Should StringGraphemeCount 8', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('e\u0301'), 1)
+})
+Test('Should StringGraphemeCount 9', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('a\u0301b\u0301'), 2)
+})
+Test('Should StringGraphemeCount 10', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('漢字'), 2)
+})
+Test('Should StringGraphemeCount 11', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('😄'), 1)
+})
+Test('Should StringGraphemeCount 12', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('😄😄😄'), 3)
+})
+Test('Should StringGraphemeCount 13', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('😄🎉🔥'), 3)
+})
+Test('Should StringGraphemeCount 14', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('Hello 😄!'), 8)
+})
+Test('Should StringGraphemeCount 15', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('𝄞'), 1)
+})
+Test('Should StringGraphemeCount 16', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('𝄞𝄞'), 2)
+})
+Test('Should StringGraphemeCount 17', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('A𝄞B'), 3)
+})
+Test('Should StringGraphemeCount 18', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('a😄b'), 3)
+})
+Test('Should StringGraphemeCount 19', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('😄🎉'), 2)
+})
+Test('Should StringGraphemeCount 20', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('🗺️'), 1)
+})
+Test('Should StringGraphemeCount 21', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('🗺️✈️'), 2)
+})
+Test('Should StringGraphemeCount 22', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('🗺️a'), 2)
+})
+Test('Should StringGraphemeCount 23', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('🗺️\u0301'), 1)
+})
+Test('Should StringGraphemeCount 24', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('🇳🇿'), 1)
+})
+Test('Should StringGraphemeCount 25', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('🇳🇿🇰🇷'), 2)
+})
+Test('Should StringGraphemeCount 26', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('NZ🇳🇿'), 3)
+})
+Test('Should StringGraphemeCount 27', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('🇳🇿😄'), 2)
+})
+Test('Should StringGraphemeCount 28', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('a😄e\u0301'), 3)
+})
+Test('Should StringGraphemeCount 29', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('😄🇳🇿e\u0301'), 3)
+})
+Test('Should StringGraphemeCount 30', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('🧳🇰🇷abc'), 5)
+})
+Test('Should StringGraphemeCount 31', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('a🇰🇷😄🗺️e\u0301'), 5)
+})
+Test('Should StringGraphemeCount 32', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('🇳🇿🇰🇷🇯🇵'), 3)
+})
+Test('Should StringGraphemeCount 33', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('a\u0301\u0323'), 1) // a + acute + dot below
+})
+Test('Should StringGraphemeCount 34', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('\u0301b'), 2) // combining mark + b
+})
+Test('Should StringGraphemeCount 35', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('\uDC00'), 1)
+})
+Test('Should StringGraphemeCount 36', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('🏝️🛳️'), 2)
+})
+Test('Should StringGraphemeCount 37', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('✈️🗺️'), 2)
+})
+Test('Should StringGraphemeCount 38', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('a🇳🇿🧳b'), 4)
+})
+Test('Should StringGraphemeCount 39', () => {
+  Assert.IsEqual(Guard.StringGraphemeCount('𝄞𝄢𝄫'), 3) // multiple musical symbols (surrogate pairs)
+})