@bessemer/cornerstone 0.5.0

package/test/object.test.ts

@@ -0,0 +1,104 @@
+import { Objects } from '@bessemer/cornerstone'
+
+test('Objects.mergeAll', () => {
+  expect(
+    Objects.mergeAll([
+      { one: 'First Value', two: 'Second Value', three: 'First Value' },
+      { one: 'Update Value' },
+      { one: 'Update Value 2', two: null, four: 'Fourth Value' },
+      { three: undefined },
+    ])
+  ).toEqual({
+    one: 'Update Value 2',
+    two: null,
+    three: 'First Value',
+    four: 'Fourth Value',
+  })
+})
+
+test('Objects.parsePath', () => {
+  expect(Objects.parsePath('')).toEqual(Objects.path([]))
+  expect(Objects.parsePath('this')).toEqual(Objects.path(['this']))
+  expect(Objects.parsePath('this.is[2].a.path')).toEqual(Objects.path(['this', 'is', 2, 'a', 'path']))
+  expect(Objects.parsePath('this.is[2].a.path[1]')).toEqual(Objects.path(['this', 'is', 2, 'a', 'path', 1]))
+})
+
+type Address = {
+  addressLine1: string
+  addressLine2: string | null
+  postcode?: number
+}
+
+type Location = {
+  name: string
+  address: Address
+}
+
+type Person = {
+  id: number
+  name: string
+  age: number
+  pets: Array<string>
+  primaryAddress: Address
+  residences: Array<Location>
+}
+
+const person: Person = {
+  id: 1234,
+  name: 'Bob Bobson',
+  age: 30,
+  pets: ['Fishy Fish', 'Yogi', 'General Bismark'],
+  primaryAddress: {
+    addressLine1: '123 Fake Street.',
+    addressLine2: 'Apt 6',
+    postcode: 77586,
+  },
+  residences: [
+    {
+      name: 'Winter Estate',
+      address: {
+        addressLine1: 'Siberia',
+        addressLine2: null,
+        postcode: 34534,
+      },
+    },
+    {
+      name: 'Summer Palace',
+      address: {
+        addressLine1: '456 Palace Avenue',
+        addressLine2: null,
+      },
+    },
+  ],
+}
+
+test('Objects.getPathValue', () => {
+  expect(Objects.getPathValue(person, 'id')).toEqual(1234)
+  expect(Objects.getPathValue(person, 'pets[1]')).toEqual('Yogi')
+  expect(Objects.getPathValue(person, 'primaryAddress.addressLine1')).toEqual('123 Fake Street.')
+  expect(Objects.getPathValue(person, 'residences[0].address')).toEqual({
+    addressLine1: 'Siberia',
+    addressLine2: null,
+    postcode: 34534,
+  })
+  expect(Objects.getPathValue(person, 'residences[2].address')).toEqual(undefined)
+  expect(Objects.getPathValue(person, 'residences.address[0]')).toEqual(undefined)
+})
+
+test('Objects.applyPathValue', () => {
+  {
+    const modifiedPerson = Objects.applyPathValue(person, 'primaryAddress.addressLine1', 'Changed!') as Person
+    expect(modifiedPerson.primaryAddress.addressLine1).toEqual('Changed!')
+    expect(person.primaryAddress.addressLine1).toEqual('123 Fake Street.')
+  }
+
+  {
+    const modifiedPerson = Objects.applyPathValue(person, 'residences[0].address', 'Changed!') as Person
+    expect(modifiedPerson.residences[0]!.address).toEqual('Changed!')
+  }
+
+  {
+    const modifiedPerson = Objects.applyPathValue(person, 'residences[3].address', 'Changed!') as Person
+    expect(modifiedPerson).toEqual(undefined)
+  }
+})

package/test/patch.test.ts

@@ -0,0 +1,170 @@
+import { Patches } from '@bessemer/cornerstone'
+import { Expressions } from '@bessemer/cornerstone/expression'
+
+test('Patch Numbers', () => {
+  {
+    const value = Patches.resolve(5, [Patches.sum(1), Patches.sum(2), Patches.sum(3)], Expressions.defaultEvaluator())
+    expect(value).toEqual(11)
+  }
+
+  {
+    const value = Patches.resolve(5, [Patches.multiply(2), Patches.sum(2), Patches.multiply(2)], Expressions.defaultEvaluator())
+    expect(value).toEqual(24)
+  }
+
+  {
+    const value = Patches.resolve(5, [Patches.set(2), Patches.sum(2), Patches.set(5)], Expressions.defaultEvaluator())
+    expect(value).toEqual(5)
+  }
+})
+
+test('Patch Objects', () => {
+  type Address = {
+    addressLine1: string
+    addressLine2: string | null
+    postcode?: number
+  }
+
+  type Location = {
+    name: string
+    address: Address
+  }
+
+  type Person = {
+    id: number
+    name: string
+    age: number
+    pets: Array<string>
+    primaryAddress: Address
+    residences: Array<Location>
+  }
+
+  const originalPerson: Person = {
+    id: 1234,
+    name: 'Bob Bobson',
+    age: 30,
+    pets: ['Fishy Fish', 'Yogi', 'General Bismark'],
+    primaryAddress: {
+      addressLine1: '123 Fake Street.',
+      addressLine2: 'Apt 6',
+      postcode: 77586,
+    },
+    residences: [
+      {
+        name: 'Winter Estate',
+        address: {
+          addressLine1: 'Siberia',
+          addressLine2: null,
+          postcode: 34534,
+        },
+      },
+      {
+        name: 'Summer Palace',
+        address: {
+          addressLine1: '456 Palace Avenue',
+          addressLine2: null,
+        },
+      },
+    ],
+  }
+
+  {
+    const updatedPerson = Patches.resolve(
+      originalPerson,
+      [
+        Patches.patch({
+          name: 'Bobby',
+          age: Patches.multiply(2),
+          pets: Patches.set(['Burly Bear']),
+          primaryAddress: {
+            addressLine2: 'New Apartment',
+          },
+        }),
+      ],
+      Expressions.defaultEvaluator()
+    )
+
+    expect(originalPerson.name).toEqual('Bob Bobson')
+    expect(updatedPerson.id).toEqual(originalPerson.id)
+    expect(updatedPerson.primaryAddress.addressLine1).toEqual(originalPerson.primaryAddress.addressLine1)
+
+    expect(updatedPerson.name).toEqual('Bobby')
+    expect(updatedPerson.age).toEqual(60)
+    expect(updatedPerson.primaryAddress.addressLine2).toEqual('New Apartment')
+    expect(updatedPerson.pets).toEqual(['Burly Bear'])
+  }
+
+  {
+    const updatedPerson = Patches.resolve(
+      originalPerson,
+      [
+        Patches.patch({
+          pets: Patches.concatenate(['Burly Bear']),
+          primaryAddress: Patches.set({
+            addressLine1: 'Another Street',
+            addressLine2: 'Apt 7',
+          }),
+        }),
+      ],
+      Expressions.defaultEvaluator()
+    )
+
+    expect(updatedPerson.pets).toEqual([...originalPerson.pets, 'Burly Bear'])
+    expect(updatedPerson.primaryAddress).toEqual({
+      addressLine1: 'Another Street',
+      addressLine2: 'Apt 7',
+    })
+  }
+
+  {
+    const updatedPerson = Patches.resolve(
+      originalPerson,
+      [
+        Patches.patch({
+          residences: [
+            {
+              name: 'Winter Chalet',
+            },
+            {
+              address: {
+                addressLine1: 'Address Line 1 Changed!',
+              },
+            },
+          ],
+        }),
+      ],
+      Expressions.defaultEvaluator()
+    )
+
+    expect(updatedPerson.residences.length).toEqual(2)
+    expect(updatedPerson.residences[0]!.name).toEqual('Winter Chalet')
+    expect(updatedPerson.residences[0]!.address.addressLine1).toEqual('Siberia')
+    expect(updatedPerson.residences[1]!.name).toEqual('Summer Palace')
+    expect(updatedPerson.residences[1]!.address.addressLine1).toEqual('Address Line 1 Changed!')
+  }
+
+  {
+    const updatedPerson = Patches.resolve(
+      originalPerson,
+      [
+        Patches.patch({
+          residences: [
+            {},
+            {
+              address: Patches.set({
+                addressLine1: 'Liberia',
+                addressLine2: null,
+              }),
+            },
+          ],
+        }),
+      ],
+      Expressions.defaultEvaluator()
+    )
+
+    expect(updatedPerson.residences[1]!.address).toEqual({
+      addressLine1: 'Liberia',
+      addressLine2: null,
+    })
+  }
+})

package/test/set.test.ts

@@ -0,0 +1,20 @@
+import { Sets } from '@bessemer/cornerstone'
+
+test('Sets.permute', () => {
+  expect(Sets.permute(['a', 'b', 'c'])).toEqual([
+    ['a', 'b', 'c'],
+    ['a', 'c', 'b'],
+    ['b', 'a', 'c'],
+    ['b', 'c', 'a'],
+    ['c', 'a', 'b'],
+    ['c', 'b', 'a'],
+  ])
+})
+
+test('Sets.properPowerSet', () => {
+  expect(Sets.properPowerSet(['a', 'b', 'c'])).toEqual([['a'], ['b'], ['a', 'b'], ['c'], ['a', 'c'], ['b', 'c'], ['a', 'b', 'c']])
+})
+
+test('Sets.powerSet', () => {
+  expect(Sets.powerSet(['a', 'b', 'c'])).toEqual([[], ['a'], ['b'], ['a', 'b'], ['c'], ['a', 'c'], ['b', 'c'], ['a', 'b', 'c']])
+})

package/test/string.test.ts

@@ -0,0 +1,22 @@
+import { Strings } from '@bessemer/cornerstone'
+
+// JOHN need to get test suite to actually run again
+test('Strings.splitFirst', () => {
+  expect(Strings.splitFirst('this.is.a.string.', '.')).toEqual({ selection: 'this', separator: '.', rest: 'is.a.string.' })
+  expect(Strings.splitFirst('', '/')).toEqual({ selection: null, separator: null, rest: '' })
+  expect(Strings.splitFirst('thisisastring', '.')).toEqual({ selection: null, separator: null, rest: 'thisisastring' })
+  expect(Strings.splitFirst('this123is123a123string', '123')).toEqual({ selection: 'this', separator: '123', rest: 'is123a123string' })
+  expect(Strings.splitFirst('/test', '/')).toEqual({ selection: '', separator: '/', rest: 'test' })
+  expect(Strings.splitFirst('test/', '/')).toEqual({ selection: 'test', separator: '/', rest: '' })
+  expect(Strings.splitFirst('//test/', '/')).toEqual({ selection: '', separator: '/', rest: '/test/' })
+})
+
+test('Strings.splitLast', () => {
+  expect(Strings.splitLast('.this.is.a.string', '.')).toEqual({ selection: 'string', separator: '.', rest: '.this.is.a' })
+  expect(Strings.splitLast('', '/')).toEqual({ selection: null, separator: null, rest: '' })
+  expect(Strings.splitLast('thisisastring', '.')).toEqual({ selection: null, separator: null, rest: 'thisisastring' })
+  expect(Strings.splitLast('this123is123a123string', '123')).toEqual({ selection: 'string', separator: '123', rest: 'this123is123a' })
+  expect(Strings.splitLast('/test', '/')).toEqual({ selection: 'test', separator: '/', rest: '' })
+  expect(Strings.splitLast('test/', '/')).toEqual({ selection: '', separator: '/', rest: 'test' })
+  expect(Strings.splitLast('//test/', '/')).toEqual({ selection: '', separator: '/', rest: '//test' })
+})

package/test/uri.test.ts

@@ -0,0 +1,111 @@
+import { Uris } from '@bessemer/cornerstone'
+
+test('Uris.parse / Uris.build', () => {
+  expect(Uris.parse('tel:+1-816-555-1212')).toEqual(
+    Uris.build({
+      scheme: 'tel',
+      location: {
+        path: '+1-816-555-1212',
+      },
+    })
+  )
+
+  expect(Uris.parse('tel:+1-816-555-1212?#')).toEqual(
+    Uris.build({
+      scheme: 'tel',
+      location: '+1-816-555-1212',
+    })
+  )
+
+  expect(Uris.parse('tel:+1-816-555-1212?#fragment')).toEqual(
+    Uris.build({
+      scheme: 'tel',
+      location: {
+        path: '+1-816-555-1212',
+        fragment: 'fragment',
+      },
+    })
+  )
+
+  expect(Uris.parse('telnet://192.0.2.16:80/')).toEqual(
+    Uris.build({
+      scheme: 'telnet',
+      host: {
+        value: '192.0.2.16',
+        port: 80,
+      },
+      location: {
+        path: '/',
+      },
+    })
+  )
+
+  expect(Uris.parse('telnet://192.0.2.16:80')).toEqual(
+    Uris.build({
+      scheme: 'telnet',
+      host: '192.0.2.16:80',
+      location: '',
+    })
+  )
+
+  expect(Uris.parse('urn:oasis:names:specification:docbook:dtd:xml:4.1.2')).toEqual(
+    Uris.build({
+      scheme: 'urn',
+      location: 'oasis:names:specification:docbook:dtd:xml:4.1.2',
+    })
+  )
+
+  expect(Uris.parse('news:comp.infosystems.www.servers.unix')).toEqual(
+    Uris.build({
+      scheme: 'news',
+      location: {
+        path: 'comp.infosystems.www.servers.unix',
+      },
+    })
+  )
+
+  expect(Uris.parse('ldap://[2001:db8::7]/c=GB?objectClass?one')).toEqual(
+    Uris.build({
+      scheme: 'ldap',
+      host: {
+        value: '[2001:db8::7]',
+      },
+      location: {
+        path: '/c=GB',
+        query: 'objectClass?one',
+      },
+    })
+  )
+
+  expect(Uris.parse('ldap://[2001:db8::7]:389/c=GB?objectClass?one')).toEqual(
+    Uris.build({
+      scheme: 'ldap',
+      host: {
+        value: '[2001:db8::7]',
+        port: 389,
+      },
+      location: {
+        path: '/c=GB',
+        query: 'objectClass?one',
+      },
+    })
+  )
+
+  expect(Uris.parse('https://john.doe@www.example.com:1234/forum/questions/?tag=networking&order=newest#:~:text=whatever')).toEqual(
+    Uris.build({
+      scheme: 'https',
+      authentication: {
+        principal: 'john.doe',
+      },
+      host: {
+        value: 'www.example.com',
+        port: 1234,
+      },
+      location: {
+        path: '/forum/questions/',
+        query: 'tag=networking&order=newest',
+        fragment: ':~:text=whatever',
+      },
+    })
+  )
+})

package/test/url.test.ts

@@ -0,0 +1,174 @@
+import { Urls } from '@bessemer/cornerstone'
+
+test('Urls.parse / Urls.build', () => {
+  {
+    expect(Urls.parse('https://www.google.com')).toEqual(
+      Urls.build({
+        scheme: 'https',
+        host: 'www.google.com',
+      })
+    )
+  }
+  {
+    expect(Urls.parse('https://www.google.com/')).toEqual(
+      Urls.build({
+        scheme: 'https',
+        host: 'www.google.com',
+      })
+    )
+  }
+
+  // TODO i think we should try and support these URLs without having to have the double slash
+  {
+    expect(Urls.parse('//www.google.com')).toEqual(
+      Urls.build({
+        host: 'www.google.com',
+      })
+    )
+  }
+
+  {
+    expect(Urls.parse('//www.google.com/')).toEqual(
+      Urls.build({
+        host: 'www.google.com',
+      })
+    )
+  }
+
+  {
+    expect(Urls.parse('http://localhost:8080')).toEqual(
+      Urls.build({
+        scheme: 'http',
+        host: {
+          value: 'localhost',
+          port: 8080,
+        },
+      })
+    )
+  }
+
+  {
+    expect(Urls.parse('http://localhost:8080/')).toEqual(
+      Urls.build({
+        scheme: 'http',
+        host: 'localhost:8080',
+      })
+    )
+  }
+  {
+    expect(Urls.parse('//localhost:8080')).toEqual(
+      Urls.build({
+        host: {
+          value: 'localhost',
+          port: 8080,
+        },
+      })
+    )
+  }
+  {
+    expect(Urls.parse('//localhost:8080/')).toEqual(
+      Urls.build({
+        host: {
+          value: 'localhost',
+          port: 8080,
+        },
+      })
+    )
+  }
+
+  {
+    expect(Urls.parse('https://john.lutteringer:password123@www.google.com')).toEqual(
+      Urls.build({
+        scheme: 'https',
+        host: 'www.google.com',
+        authentication: {
+          principal: 'john.lutteringer',
+          password: 'password123',
+        },
+      })
+    )
+  }
+
+  {
+    expect(Urls.parse('https://john.lutteringer:password123@www.google.com/')).toEqual(
+      Urls.build({
+        scheme: 'https',
+        host: 'www.google.com',
+        authentication: 'john.lutteringer:password123',
+      })
+    )
+  }
+
+  {
+    expect(Urls.parse('https://john.lutteringer@www.google.com/')).toEqual(
+      Urls.build({
+        scheme: 'https',
+        host: 'www.google.com',
+        authentication: 'john.lutteringer',
+      })
+    )
+  }
+
+  {
+    expect(Urls.parse('john.lutteringer@www.google.com')).toEqual(
+      Urls.build({
+        host: 'www.google.com',
+        authentication: {
+          principal: 'john.lutteringer',
+        },
+      })
+    )
+  }
+
+  {
+    expect(Urls.parse('//john.lutteringer:password123@www.google.com')).toEqual(
+      Urls.build({
+        host: 'www.google.com',
+        authentication: {
+          principal: 'john.lutteringer',
+          password: 'password123',
+        },
+      })
+    )
+  }
+
+  {
+    expect(Urls.parse('//www.google.com?q=Search%20Query')).toEqual(
+      Urls.build({
+        host: 'www.google.com',
+        location: {
+          path: '',
+          parameters: {
+            q: 'Search Query',
+          },
+        },
+      })
+    )
+  }
+
+  {
+    expect(Urls.parse('/search?q=Search%20Query')).toEqual(
+      Urls.build({
+        location: {
+          path: '/search',
+          parameters: {
+            q: 'Search Query',
+          },
+        },
+      })
+    )
+  }
+
+  {
+    expect(Urls.parse('search?q=Search%20Query')).toEqual(
+      Urls.build({
+        location: {
+          path: 'search',
+          parameters: {
+            q: 'Search Query',
+          },
+        },
+      })
+    )
+  }
+})

package/tsconfig.build.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.lib.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src",
+    "baseUrl": ".",
+    "paths": {
+      "@bessemer/cornerstone": ["src"],
+      "@bessemer/cornerstone/*": ["src/*"]
+    }
+  },
+  "exclude": ["dist", "node_modules", "test" ,"tsup.config.ts", "jest.config.js"]
+}

package/tsup.config.ts

@@ -0,0 +1,4 @@
+import { defineConfig } from 'tsup'
+import { Config } from '../tsup.base.js'
+
+export default defineConfig(Config)