@ditojs/utils 2.100.0 → 3.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ditojs/utils",
-  "version": "2.100.0",
+  "version": "3.1.0",
   "type": "module",
   "description": "Dito.js Utility Functions – Dito.js is a declarative and modern web framework, based on Objection.js, Koa.js and Vue.js",
   "repository": "https://github.com/ditojs/dito/tree/main/packages/utils",
@@ -17,11 +17,10 @@
   },
   "files": [
     "src/",
-    "types/"
+    "types/",
+    "!src/**/*.test.js",
+    "!src/**/__snapshots__/"
   ],
-  "scripts": {
-    "types": "tsc --noEmit types/index.d.ts"
-  },
   "engines": {
     "node": ">= 24.0.0"
   },
@@ -32,11 +31,8 @@
     "ie >= 11",
     "ie_mob >= 11"
   ],
-  "dependencies": {
-    "punycode": "^2.3.1"
-  },
   "devDependencies": {
     "typescript": "^6.0.3"
   },
-  "gitHead": "c6fdbe03971188779fc9cf5f1b4202e08bc75a65"
+  "gitHead": "97314265c5cbac6a248d7350f43fea8ea92b995f"
 }

package/src/array/shuffle.js

@@ -1,7 +1,7 @@
 export function shuffle(array) {
   // Do the Fisher-Yates (aka Knuth) Shuffle:
   const res = array.slice()
-  for (let i = array.length; i; ) {
+  for (let i = array.length; i;) {
     const r = Math.floor(Math.random() * i)
     const t = res[--i]
     res[i] = res[r]

package/src/string/formatPlainDate.js

@@ -0,0 +1,14 @@
+/**
+ * Formats a date as its local plain date, e.g. `'2026-05-14'`, without the
+ * time and time zone of `toISOString()`, which can shift it to another day.
+ */
+export function formatPlainDate(date) {
+  // Use the date parts, as shifting by `getTimezoneOffset()` misses offsets
+  // with seconds, e.g. local mean time before 1894 in Europe/Zurich.
+  const pad = (number, length = 2) => String(number).padStart(length, '0')
+  return [
+    pad(date.getFullYear(), 4),
+    pad(date.getMonth() + 1),
+    pad(date.getDate())
+  ].join('-')
+}

package/src/string/index.js

@@ -4,6 +4,7 @@ export * from './decamelize.js'
 export * from './deindent.js'
 export * from './escapeRegexp.js'
 export * from './format.js'
+export * from './formatPlainDate.js'
 export * from './formatDate.js'
 export * from './getCommonPrefix.js'
 export * from './isAbsoluteUrl.js'
@@ -13,3 +14,4 @@ export * from './isEmail.js'
 export * from './isHostname.js'
 export * from './isUrl.js'
 export * from './labelize.js'
+export * from './parsePlainDate.js'

package/src/string/isDomain.js

@@ -1,9 +1,16 @@
-import punycode from 'punycode/punycode.js'
-
 // Best effort approach, allowing Internationalized domain name (with punycode)
 const domainRegExp =
   /^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z0-9][a-z0-9-]{0,61}[a-z0-9]$/i
 
 export function isDomain(str) {
-  return !!(str && domainRegExp.test(punycode.toASCII(str)))
+  // Reject characters that `URL` would treat as delimiters or decode, so that
+  // only the domain itself is converted to its ASCII (punycode) form.
+  if (!str || /[\s/\\?#@:%]/.test(str)) {
+    return false
+  }
+  try {
+    return domainRegExp.test(new URL(`http://${str}`).hostname)
+  } catch {
+    return false
+  }
 }

package/src/string/parsePlainDate.js

@@ -0,0 +1,18 @@
+import { formatPlainDate } from './formatPlainDate.js'
+
+/**
+ * Parses a plain date like `'2026-05-14'` as local midnight, unlike
+ * `new Date()`, which parses it as UTC midnight. Returns `null` for anything
+ * else, including invalid dates like `'2026-02-30'`.
+ */
+export function parsePlainDate(string) {
+  if (/^\d{4}-\d{2}-\d{2}$/.test(string)) {
+    // Date-time strings without an offset are parsed as local time.
+    const date = new Date(`${string}T00:00`)
+    // Reject invalid days, which `Date` rolls over to the next month.
+    if (formatPlainDate(date) === string) {
+      return date
+    }
+  }
+  return null
+}

package/types/index.d.ts

@@ -518,6 +518,19 @@ export function format(
     }
   }
 ): string | null | undefined
+/**
+ * Formats a date as its local plain date, e.g. `'2026-05-14'`, without the
+ * time and time zone of `toISOString()`, which can shift it to another day.
+ */
+export function formatPlainDate(date: Date): string
+/**
+ * Parses a plain date like `'2026-05-14'` as local midnight, unlike
+ * `new Date()`, which parses it as UTC midnight. Returns `null` for anything
+ * else, including invalid dates like `'2026-02-30'`.
+ */
+export function parsePlainDate(
+  string: string | null | undefined
+): Date | null
 /**
  * Formats a date value as a string. If the value is not a Date,
  * attempts to convert it to a Date first.

package/src/__snapshots__/index.test.js.snap

@@ -1,88 +0,0 @@
-// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
-
-exports[`index > exports all symbols 1`] = `
-{
-  "asArray": [Function],
-  "asFunction": [Function],
-  "asObject": [Function],
-  "assignDeeply": [Function],
-  "camelize": [Function],
-  "capitalize": [Function],
-  "clone": [Function],
-  "debounce": [Function],
-  "debounceAsync": [Function],
-  "decamelize": [Function],
-  "defaultFormats": {
-    "date": {
-      "day": "numeric",
-      "month": "long",
-      "year": "numeric",
-    },
-    "number": {
-      "style": "decimal",
-    },
-    "time": {
-      "hour": "2-digit",
-      "minute": "2-digit",
-      "second": "2-digit",
-    },
-  },
-  "deindent": [Function],
-  "deprecate": [Function],
-  "equals": [Function],
-  "escapeHtml": [Function],
-  "escapeRegexp": [Function],
-  "flatten": [Function],
-  "format": [Function],
-  "formatDate": [Function],
-  "getCommonOffset": [Function],
-  "getCommonPrefix": [Function],
-  "getEntriesAtDataPath": [Function],
-  "getValueAtDataPath": [Function],
-  "groupBy": [Function],
-  "hyphenate": [Function],
-  "is": [Function],
-  "isAbsoluteUrl": [Function],
-  "isArray": [Function],
-  "isArrayLike": [Function],
-  "isAsync": [Function],
-  "isBoolean": [Function],
-  "isCreditCard": [Function],
-  "isDate": [Function],
-  "isDomain": [Function],
-  "isEmail": [Function],
-  "isEmpty": [Function],
-  "isFunction": [Function],
-  "isHostname": [Function],
-  "isInteger": [Function],
-  "isModule": [Function],
-  "isNumber": [Function],
-  "isObject": [Function],
-  "isPlainArray": [Function],
-  "isPlainObject": [Function],
-  "isPromise": [Function],
-  "isRegExp": [Function],
-  "isString": [Function],
-  "isUrl": [Function],
-  "labelize": [Function],
-  "mapConcurrently": [Function],
-  "mapKeys": [Function],
-  "mapSequentially": [Function],
-  "mapValues": [Function],
-  "mergeDeeply": [Function],
-  "mixin": [Function],
-  "normalizeDataPath": [Function],
-  "parseDataPath": [Function],
-  "pick": [Function],
-  "pickBy": [Function],
-  "setDataPathEntries": [Function],
-  "setValueAtDataPath": [Function],
-  "shuffle": [Function],
-  "stripHtml": [Function],
-  "stripTags": [Function],
-  "toAsync": [Function],
-  "toCallback": [Function],
-  "toPromiseCallback": [Function],
-  "underscore": [Function],
-}
-`;

package/src/array/flattten.test.js

@@ -1,29 +0,0 @@
-import { flatten } from './flatten.js'
-
-describe('flatten()', () => {
-  it('should support flattening of nested arrays', () => {
-    const array = [1, [2, [3, [4]], 5]]
-    expect(flatten(array)).toStrictEqual([1, 2, 3, 4, 5])
-    expect(flatten(array, 1)).toStrictEqual([1, 2, [3, [4]], 5])
-    expect(flatten(array, 2)).toStrictEqual([1, 2, 3, [4], 5])
-  })
-
-  it('should work with empty arrays', () => {
-    const array = [[], [[]], [[], [[[]]]]]
-
-    expect(flatten(array)).toStrictEqual([])
-    expect(flatten(array, 1)).toStrictEqual([[], [], [[[]]]])
-    expect(flatten(array, 2)).toStrictEqual([[[]]])
-  })
-
-  it('should treat sparse arrays as dense', () => {
-    const array = [[1, 2, 3], Array(3)]
-    const expected = [1, 2, 3]
-    expected.push(undefined, undefined, undefined)
-    expect(flatten(array)).toStrictEqual(expected)
-  })
-
-  it('should return an empty array for non array-like objects', () => {
-    expect(flatten({ 0: 'a' })).toStrictEqual([])
-  })
-})

package/src/array/shuffle.test.js

@@ -1,25 +0,0 @@
-import { shuffle } from './shuffle.js'
-
-describe('shuffle()', () => {
-  const array = [1, 2, 3]
-
-  it('should return a new array', () => {
-    expect(shuffle(array)).not.toBe(array)
-  })
-
-  it(`should contain the same elements after a collection is shuffled and sorted again`, () => {
-    expect(shuffle(array).sort()).toStrictEqual(array)
-  })
-
-  it('should shuffle small collections', () => {
-    const results = {}
-    for (let i = 0; i < 1000; i++) {
-      const res = shuffle([1, 2])
-      results[res] = res
-    }
-    const sorted = Object.entries(results)
-      .sort()
-      .map(([, value]) => value)
-    expect(sorted).toStrictEqual([[1, 2], [2, 1]])
-  })
-})