@nordcraft/core 1.0.0

package/src/utils/collections.ts

@@ -0,0 +1,122 @@
+import { isDefined } from './util'
+
+export const isObject = (input: any): input is Record<string, any> =>
+  typeof input === 'object' && input !== null
+
+export const mapObject = <T, T2>(
+  object: Record<string, T>,
+  f: (kv: [string, T]) => [string, T2],
+): Record<string, T2> => Object.fromEntries(Object.entries(object).map(f))
+
+export const mapValues = <T, T2>(
+  object: Record<string, T>,
+  f: (value: T) => T2,
+): Record<string, T2> => mapObject(object, ([key, value]) => [key, f(value)])
+
+/**
+ * Deletes potentially nested keys from an object
+ * @param collection Array or Object
+ * @param path Path to the key to delete. For instance ['foo', 0, 'bar']
+ * @returns The updated object/array
+ */
+export const omit = <T = unknown>(collection: T, path: string[]): T => {
+  const [head, ...rest] = path
+
+  const clone: any = Array.isArray(collection)
+    ? [...collection]
+    : isObject(collection)
+      ? { ...collection }
+      : {}
+
+  if (rest.length === 0) {
+    delete clone[head]
+  } else {
+    clone[head] = omit(clone[head], rest)
+  }
+  return clone as T
+}
+
+export const omitKeys = <T extends Record<string, any>>(
+  object: T,
+  keys: Array<keyof T>,
+): T =>
+  Object.fromEntries(
+    Object.entries(object).filter(([k]) => !keys.includes(k)),
+  ) as T
+
+export const omitPaths = (object: Record<string, any>, keys: string[][]) =>
+  keys.reduce((acc, key) => omit(acc, key), { ...object })
+
+export const groupBy = <T>(items: T[], f: (t: T) => string) =>
+  items.reduce<Record<string, T[]>>((acc, item) => {
+    const key = f(item)
+    acc[key] = acc[key] ?? []
+    acc[key].push(item)
+    return acc
+  }, {})
+
+export const filterObject = <T>(
+  object: Record<string, T>,
+  f: (kv: [string, T]) => boolean,
+): Record<string, T> => Object.fromEntries(Object.entries(object).filter(f))
+
+export function get<T = any>(collection: T, [head, ...rest]: string[]): any {
+  if (rest.length === 0) {
+    return (collection as any)?.[head]
+  }
+  return get((collection as any)?.[head], rest)
+}
+
+export const set = <T = unknown>(
+  collection: T,
+  key: string[],
+  value: any,
+): T => {
+  const [head, ...rest] = key
+
+  const clone: any = Array.isArray(collection)
+    ? [...collection]
+    : isObject(collection)
+      ? { ...collection }
+      : {}
+
+  clone[head] = rest.length === 0 ? value : set(clone[head], rest, value)
+  return clone as T
+}
+
+export const sortObjectEntries = <T>(
+  object: Record<string, T>,
+  f: (kv: [string, T]) => string | number | boolean,
+  ascending = true,
+): [string, T][] => easySort(Object.entries(object), f, ascending)
+
+export const easySort = <T>(
+  collection: T[],
+  f: (item: T) => string | number | boolean,
+  ascending = true,
+) =>
+  [...collection].sort((a, b) => {
+    const keyA = f(a)
+    const keyB = f(b)
+    if (keyA === keyB) {
+      return 0
+    }
+    return (keyA > keyB ? 1 : -1) * (ascending ? 1 : -1)
+  })
+
+export const deepSortObject = (
+  obj: any,
+): Record<string, any> | Array<any> | undefined | null => {
+  if (!isDefined(obj)) {
+    return obj
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((val) => deepSortObject(val))
+  } else if (typeof obj === 'object' && Object.keys(obj).length > 0) {
+    return [...Object.keys(obj)].sort().reduce<any>((acc, key) => {
+      acc[key] = deepSortObject(obj[key])
+      return acc
+    }, {})
+  }
+  return obj
+}

package/src/utils/customElements.test.ts

@@ -0,0 +1,40 @@
+import { safeCustomElementName } from './customElements'
+// cSpell:ignore mycustomelement, myelement
+
+describe('safeCustomElementName', () => {
+  test('should remove leading and trailing white-spaces', () => {
+    const input = '  MyCustomElement  '
+    const result = safeCustomElementName(input)
+    expect(result).toBe('toddle-mycustomelement')
+  })
+
+  test('should convert input to lowercase', () => {
+    const input = 'MyCustomElement'
+    const result = safeCustomElementName(input)
+    expect(result).toBe('toddle-mycustomelement')
+  })
+
+  test('should remove white-spaces from the middle', () => {
+    const input = 'My Custom Element'
+    const result = safeCustomElementName(input)
+    expect(result).toBe('toddle-mycustomelement')
+  })
+
+  test('should add "toddle-" prefix if no hyphen', () => {
+    const input = 'MyElement'
+    const result = safeCustomElementName(input)
+    expect(result).toBe('toddle-myelement')
+  })
+
+  test('should not add "toddle-" prefix if hyphen is present', () => {
+    const input = 'my-custom-element'
+    const result = safeCustomElementName(input)
+    expect(result).toBe('my-custom-element')
+  })
+
+  test('should remove multiple consecutive white-spaces', () => {
+    const input = '  My   Custom  Element  '
+    const result = safeCustomElementName(input)
+    expect(result).toBe('toddle-mycustomelement')
+  })
+})

package/src/utils/customElements.ts

@@ -0,0 +1,16 @@
+/**
+ * Convert a component name to a valid HTML tag name according to the custom-element specs
+ *
+ * https://html.spec.whatwg.org/multipage/custom-elements.html#custom-element
+ */
+export const safeCustomElementName = (name: string) => {
+  // Remove any white spaces from the name
+  const tag = name.toLocaleLowerCase().replaceAll(' ', '')
+
+  // Add "toddle-" prefix if needed
+  if (!tag.includes('-')) {
+    return `toddle-${tag}`
+  }
+
+  return tag
+}

package/src/utils/hash.test.ts

@@ -0,0 +1,32 @@
+import { hash } from './hash'
+
+describe('hash', () => {
+  test('identical strings should lead to the same hash', () => {
+    const data1 = "{ foo: 'bar', time: now }"
+    const data2 = "{ foo: 'bar', time: now }"
+    const firstHash = hash(data1)
+    const secondHash = hash(data2)
+    expect(firstHash).toEqual(secondHash)
+  })
+  test('identical strings with same seed should lead to the same hash', () => {
+    const data1 = "{ foo: 'bar', time: now }"
+    const data2 = "{ foo: 'bar', time: now }"
+    const firstHash = hash(data1, 10)
+    const secondHash = hash(data2, 10)
+    expect(firstHash).toEqual(secondHash)
+  })
+  test('identical strings with different seed should lead different hashes', () => {
+    const data1 = "{ foo: 'bar', time: now }"
+    const data2 = "{ foo: 'bar', time: now }"
+    const firstHash = hash(data1, 10)
+    const secondHash = hash(data2, 5)
+    expect(firstHash).not.toEqual(secondHash)
+  })
+  test('different strings results in different hash values', () => {
+    const data1 = "{ foo: 'bar', time: now }"
+    const firstHash = hash(data1)
+    const data2 = "{ foo: 'bar', time: new Date(now.getTime() + 1000) }"
+    const secondHash = hash(data2)
+    expect(firstHash).not.toEqual(secondHash)
+  })
+})

package/src/utils/hash.ts

@@ -0,0 +1,18 @@
+// Based on https://stackoverflow.com/questions/7616461/generate-a-hash-from-string-in-javascript/52171480#52171480
+// This is a simple hash function for strings. It's not secure, but it's fast.
+// It's not suitable for cryptographic purposes, but it's great for hash tables.
+export const hash = (data: string, seed = 0) => {
+  let h1 = 0xdeadbeef ^ seed,
+    h2 = 0x41c6ce57 ^ seed
+  for (let i = 0, ch; i < data.length; i++) {
+    ch = data.charCodeAt(i)
+    h1 = Math.imul(h1 ^ ch, 2654435761)
+    h2 = Math.imul(h2 ^ ch, 1597334677)
+  }
+  h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507)
+  h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909)
+  h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507)
+  h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909)
+
+  return 4294967296 * (2097151 & h2) + (h1 >>> 0)
+}

package/src/utils/json.ts

@@ -0,0 +1,18 @@
+const iso8601Regex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:.\d{1,3})?Z$/
+
+/**
+ * This function is much slower than JSON parse without reviver and is a major
+ * bottleneck in the runtime performance. Especially during startup.
+ */
+export function parseJSONWithDate(input: string) {
+  return JSON.parse(input, (_, value) => {
+    if (
+      typeof value === 'string' &&
+      value.length === 24 &&
+      iso8601Regex.test(value)
+    ) {
+      return new Date(value)
+    }
+    return value
+  })
+}

package/src/utils/sha1.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, test } from '@jest/globals'
+import crypto from 'crypto'
+import { deepSortObject } from './collections'
+import { sha1, stableStringify } from './sha1'
+;(global as any).crypto = crypto
+
+describe('sha1', () => {
+  test('calculating sha1 of an object works', async () => {
+    const data = { foo: 'bar' }
+    const sha = await sha1(data)
+    expect(sha).toHaveLength(40)
+  })
+  test('identical objects should lead to the same sha', async () => {
+    const now = new Date()
+    const data1 = { foo: 'bar', time: now }
+    const data2 = { foo: 'bar', time: now }
+    const firstSha = await sha1(data1)
+    const secondSha = await sha1(data2)
+    expect(firstSha).toEqual(secondSha)
+  })
+  test('variations of an object results in different sha values', async () => {
+    const now = new Date()
+    const data1 = { foo: 'bar', time: now }
+    const firstSha = await sha1(data1)
+    const data2 = { foo: 'bar', time: new Date(now.getTime() + 1000) }
+    const secondSha = await sha1(data2)
+    expect(firstSha).not.toEqual(secondSha)
+  })
+  test('stableStringify', () => {
+    const now = new Date()
+    expect(stableStringify({ time: now, foo: 'bar' })).toEqual(
+      `{"foo":"bar","time":"${now.toJSON()}"}`,
+    )
+  })
+  test('sortObject sorts object keys as expected', () => {
+    expect(
+      deepSortObject({
+        c: 'test',
+        b: [3, 2, { b: 0, a: 1 }],
+        d: undefined,
+        a: { 2: 'val', 1: 'foo' },
+      }),
+    ).toEqual({
+      a: { 1: 'foo', 2: 'val' },
+      b: [3, 2, { a: 1, b: 0 }],
+      c: 'test',
+      d: undefined,
+    })
+  })
+})

package/src/utils/sha1.ts

@@ -0,0 +1,17 @@
+import { deepSortObject } from './collections'
+
+export const stableStringify = (obj: any) => JSON.stringify(deepSortObject(obj))
+
+export const sha1 = async (data: any) => {
+  const payload = new Uint8Array(
+    stableStringify(data)
+      .split('')
+      .map(function (c) {
+        return c.charCodeAt(0)
+      }),
+  )
+
+  const hashBuffer = await crypto.subtle.digest('SHA-1', payload)
+  const hashArray = Array.from(new Uint8Array(hashBuffer)) // convert buffer to byte array
+  return hashArray.map((b) => b.toString(16).padStart(2, '0')).join('')
+}

package/src/utils/url.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, test } from '@jest/globals'
+import { validateUrl } from './url'
+
+describe('validateUrl()', () => {
+  test('it validates urls correctly', () => {
+    expect(validateUrl('https://toddle.dev')).toBeInstanceOf(URL)
+    expect(validateUrl('not-a-url')).toBe(false)
+  })
+
+  test('it validates urls arrays in query params correctly', async () => {
+    const url = validateUrl('https://toddle.dev?test=1&test=2')
+    expect(url).toBeInstanceOf(URL)
+    if (url instanceof URL) {
+      expect(url.searchParams.getAll('test')).toEqual(['1', '2'])
+    }
+  })
+})

package/src/utils/url.ts

@@ -0,0 +1,33 @@
+const LOCALHOSTS = ['http://localhost:54404', 'http://preview.localhost:54404']
+
+export const isLocalhostUrl = (hrefOrOrigin: string) =>
+  LOCALHOSTS.some((host) => hrefOrOrigin.startsWith(host))
+
+export const isLocalhostHostname = (hostname: string) =>
+  hostname === 'localhost' || hostname === '127.0.0.1'
+
+export const validateUrl = (url?: string | null, base?: string) => {
+  if (typeof url !== 'string') {
+    return false
+  }
+
+  try {
+    const urlObject = new URL(url, base)
+    // Creating a new URL object will not correctly encode the search params
+    // So we need to iterate over them to make sure they are encoded as that happens when setting them explicitly
+    const searchCopy = new URLSearchParams(urlObject.searchParams)
+    searchCopy.forEach((value, key) => {
+      urlObject.searchParams.delete(key, value)
+    })
+    searchCopy.forEach((value, key) => {
+      urlObject.searchParams.append(key, value)
+    })
+    return urlObject
+  } catch {
+    return false
+  }
+}
+
+export const PROXY_URL_HEADER = 'x-toddle-url'
+
+export const REWRITE_HEADER = 'x-toddle-rewrite'

package/src/utils/util.ts

@@ -0,0 +1,8 @@
+export const isDefined = <T>(value: T | undefined | null): value is T =>
+  value !== null && value !== undefined
+
+export const isObject = (input: any): input is Record<string, any> =>
+  typeof input === 'object' && input !== null
+
+export const toBoolean = (value: any) =>
+  value !== false && value !== undefined && value !== null