turtb 0.5.0

package/lib/utils/components.js

@@ -0,0 +1,88 @@
+import { b64ToUi8 } from '../dataModel/Committer.js'
+import { h } from '../display/h.js'
+import { getPointerByPublicKey } from '../net/Peer.js'
+
+export const getCpkSlice = cpk => b64ToUi8(cpk).slice(0, 6).map(n => `0${n.toString(16)}`.slice(-2)).join('')
+export const getBase = relativePath => relativePath.match(/(?<base>[^/]*)\.[^/]*$/)?.groups?.base
+
+export const buildElementName = (relativePath, address, cpk) => {
+  const base = getBase(relativePath)
+  const cpkSlice = getCpkSlice(cpk)
+  return `${base}-${cpkSlice}-${address}`
+}
+
+export const componentAtPath = (relativePath, cpk, baseElement) => {
+  const componentsByKey = {}
+  return (attributes = {}, children = []) => {
+    if (typeof cpk === 'function') cpk = cpk()
+    const elementName = componentNameAtPath(relativePath, cpk)
+    // logTrace(() => console.log('componentAtPath', { relativePath, cpk, elementName }))
+    if (elementName) {
+      const { key } = attributes
+      if (key && componentsByKey[key]) return componentsByKey[key]
+      let component
+      if (baseElement) {
+        component = h`<${baseElement} is=${elementName} ${attributes}>${children}</>`
+      } else {
+        component = h`<${elementName} ${attributes}>${children}</>`
+      }
+      if (key) {
+        componentsByKey[key] = component
+      }
+      return component
+    }
+    return 'loading...'
+  }
+}
+
+export const componentNameAtPath = (relativePath, cpk) => {
+  const turtle = getPointerByPublicKey(cpk)
+  const fsRefs = turtle.getRefs(turtle.getAddress(), 'value', 'fs')
+  if (!fsRefs) return
+  const address = fsRefs[relativePath]
+  if (address === undefined) return
+  const elementName = buildElementName(relativePath, address, cpk)
+  return elementName
+}
+
+/**
+ * @param {string} url
+ * @returns {{parsedURL: string, address: number, cpk: string, pointer: import('../dataModel/Uint8ArrayLayerPointer.js').Uint8ArrayLayerPointer, recaller: import('./Recaller.js').Recaller, elementName: string}}
+ **/
+export const deriveDefaults = url => {
+  const parsedURL = new URL(url)
+  const address = parsedURL.searchParams.get('address')
+  const cpk = parsedURL.searchParams.get('cpk')
+  const pointer = getPointerByPublicKey(cpk)
+  const recaller = pointer.recaller
+  const elementName = buildElementName(parsedURL.pathname, address, cpk)
+  return { parsedURL, address, cpk, pointer, recaller, elementName }
+}
+
+export const parseLocation = () => ({ hash: window.location?.hash?.slice?.(1) })
+
+const hashStateByRecaller = new Map()
+export const useHash = recaller => {
+  if (!hashStateByRecaller.has(recaller)) {
+    let hash = ''
+    const setCpk = (newHash = '') => {
+      if (hash === newHash) return
+      hash = newHash
+      if (parseLocation().hash !== hash) {
+        window.history.pushState({}, '', `#${hash}`)
+      }
+      recaller.reportKeyMutation(recaller, 'hash', 'setCpk', 'window.location')
+    }
+    const getCpk = () => {
+      recaller.reportKeyAccess(recaller, 'hash', 'getCpk', 'window.location')
+      return parseLocation().hash
+    }
+    const updateHashState = () => {
+      setCpk(parseLocation().hash)
+    }
+    window.addEventListener('hashchange', () => updateHashState())
+    updateHashState()
+    hashStateByRecaller.set(recaller, { setCpk, getCpk, updateHashState })
+  }
+  return hashStateByRecaller.get(recaller)
+}

package/lib/utils/crypto.js

@@ -0,0 +1,17 @@
+export const cryptoPromise = (typeof crypto === 'undefined') ? import('crypto') : crypto
+
+export const hashNameAndPassword = async (username, password, iterations = 100000) => {
+  const { subtle } = await cryptoPromise
+  const passwordKey = await subtle.importKey('raw', new TextEncoder().encode(password), 'PBKDF2', false, ['deriveBits', 'deriveKey'])
+  const hashwordKey = await subtle.deriveKey(
+    { name: 'PBKDF2', salt: new TextEncoder().encode(username), iterations, hash: 'SHA-256' },
+    passwordKey,
+    { name: 'HMAC', hash: 'SHA-256' },
+    true,
+    ['sign']
+  )
+  return b2h(new Uint8Array(await subtle.exportKey('raw', hashwordKey)).slice(32))
+}
+
+const padh = (n, pad) => n.toString(16).padStart(pad, '0')
+const b2h = (b) => Array.from(b).map(e => padh(e, 2)).join('') // bytes to hex

package/lib/utils/deepEqual.js

@@ -0,0 +1,16 @@
+export function deepEqual (a, b) {
+  if (!a !== !b) return false
+  if (!a && !b && a === b) return true
+  const aType = typeof a
+  const bType = typeof b
+  if (aType !== bType) return false
+  if (aType !== 'object') return a === b
+  if (
+    !(a.constructor.name === 'Object' && b.constructor.name === 'Object') &&
+    (a.constructor !== b.constructor)
+  ) return false
+  const aKeys = Object.keys(a)
+  const bKeys = Object.keys(b)
+  if (aKeys.length !== bKeys.length) return false
+  return aKeys.every(key => deepEqual(a[key], b[key]))
+}

package/lib/utils/deepEqual.test.js

@@ -0,0 +1,27 @@
+import { deepEqual } from "./deepEqual.js";
+import { globalTestRunner, urlToName } from "./TestRunner.js";
+
+globalTestRunner.describe(urlToName(import.meta.url), suite => {
+  suite.it('can tell same things from different things', ({ assert }) => {
+    assert.assert(deepEqual(
+      new Uint8Array([1,2,3]),
+      new Uint8Array([1,2,3])
+    ))
+    assert.assert(!deepEqual(
+      new Uint8Array([1,2,3]),
+      new Uint16Array([1,2,3])
+    ))
+    assert.assert(!deepEqual( null, undefined))
+    assert.assert(deepEqual( null, null))
+    assert.assert(deepEqual( undefined, undefined))
+    assert.assert(deepEqual( 'asdf', 'asdf'))
+    assert.assert(deepEqual(
+      [new Uint8Array([1,2,3])],
+      [new Uint8Array([1,2,3])]
+    ))
+    assert.assert(deepEqual(
+      {a: 1, b: [new Uint8Array([1,2,3])]},
+      {a: 1, b: [new Uint8Array([1,2,3])]}
+    ))
+  })
+})

package/lib/utils/fileTransformer.js

@@ -0,0 +1,16 @@
+export const textFileExtensions = ['js', 'html', 'css', 'txt', 'gitignore']
+export const jsonFileExtensions = ['json']
+
+export const TEXT_FILE = 'text file'
+export const JSON_FILE = 'json file'
+export const BINARY_FILE = 'binary file'
+
+export const pathToType = path => {
+  const extension = path.split('.').pop()
+  if (textFileExtensions.includes(extension)) return TEXT_FILE
+  if (jsonFileExtensions.includes(extension)) return JSON_FILE
+  return BINARY_FILE
+}
+
+export const stringToLines = string => string.split('\n')
+export const linesToString = lines => (typeof lines === 'string' && lines) || (Array.isArray(lines) && lines.join('\n')) || ''

package/lib/utils/handleRedirect.js

@@ -0,0 +1,93 @@
+import { logDebug, logError, logInfo } from './logger.js'
+
+/**
+ * @typedef {import('../turtle/connections/TurtleDB.js').TurtleDB} TurtleDB
+ */
+
+export const defaultPublicKey = 'ctclduqytfepmxfpxe8561b8h75l4u5n2t3sxlrmfc889xjz57'
+
+/**
+ *
+ * @param {URL} url
+ * @param {string} address
+ * @param {TurtleDB} turtleDB
+ * @param {string} publicKey
+ * @param {string} turtleDBFolder
+ * @param {(href: string) => void} redirect
+ * @param {(type: string, body: string) => void} reply
+ */
+export const handleRedirect = async (url, address, turtleDB, publicKey = defaultPublicKey, turtleDBFolder, redirect, reply) => {
+  const type = url.split('.').pop()
+  if (url === '/') {
+    console.log('let us index')
+    return redirect('/index.html')
+  }
+  try {
+    let directories = url.split('/')
+    if (directories[0] === '') directories.shift()
+    else throw new Error('url must start with /')
+    let urlPublicKey = publicKey
+    if (/^[0-9A-Za-z]{50}$/.test(directories[0])) {
+      urlPublicKey = directories.shift()
+    }
+    if (directories[directories.length - 1] === '') {
+      directories[directories.length - 1] = 'index.html'
+      return redirect(`/${urlPublicKey}/index.html`)
+    }
+    const unfilteredLength = directories.length
+    directories = directories.filter(Boolean)
+    if (unfilteredLength !== directories.length) {
+      return redirect(`/${urlPublicKey}/${directories.join('/')}`)
+    }
+    const turtleBranch = await turtleDB.summonBoundTurtleBranch(urlPublicKey)
+    const body = turtleBranch.lookupFile(directories.join('/'), false, +address)
+    if (body) {
+      return reply(type, body)
+    } else {
+      try {
+        const symlink = turtleBranch.lookupFile(directories[0])?.symlink
+        if (symlink) {
+          console.log(symlink)
+          const symlinkPublicKey = symlink.match(/.*\/(?<publicKey>[0-9A-Za-z]{50})$/)?.groups?.publicKey
+          if (symlinkPublicKey) {
+            return redirect(`/${symlinkPublicKey}/${directories.slice(1).join('/')}`)
+          }
+        }
+        const configJson = turtleBranch.lookupFile('config.json')
+        const packageJson = turtleBranch.lookupFile('package.json')
+        if (configJson) {
+          const config = JSON.parse(configJson)
+          logInfo(() => console.log({ config }))
+          const branchGroups = ['fsReadWrite', 'fsReadOnly']
+          for (const branchGroup of branchGroups) {
+            const branches = config[branchGroup]
+            if (branches) {
+              for (const { name, key } of branches) {
+                if (name && key) {
+                  if (directories[0] === name) {
+                    return redirect(`/${key}/${directories.slice(1).join('/')}`)
+                  }
+                }
+              }
+            }
+          }
+        } else if (packageJson) {
+          const aliases = JSON.parse(packageJson).turtle.aliases
+          if (aliases && directories.join('/').startsWith(`${turtleDBFolder}/aliases/`)) {
+            directories.shift()
+            const name = directories.shift()
+            const key = aliases[name]
+            if (key) {
+              return redirect(`/${key}/${directories.join('/')}`)
+            }
+          }
+        }
+      } catch {
+        logDebug(() => console.log('not found, no config', url.pathname))
+      }
+    }
+  } catch (error) {
+    logError(() => console.error(error))
+  }
+  return reply(type, null)
+}

package/lib/utils/logger.js

@@ -0,0 +1,24 @@
+export const OFF = Number.NEGATIVE_INFINITY
+export const FATAL = -3
+export const ERROR = -2
+export const WARN = -1
+export const INFO = 0
+export const DEBUG = 1
+export const TRACE = 2
+export const SILLY = 3
+export const ALL = Number.POSITIVE_INFINITY
+export let logLevel = INFO
+export const LOG_LEVELS = { OFF, FATAL, ERROR, WARN, INFO, DEBUG, TRACE, SILLY, ALL }
+export const setLogLevel = level => { logLevel = level }
+export const log = (level, ...args) => {
+  if (level > +logLevel) return
+  if (args.length === 1 && typeof args[0] === 'function') args[0]()
+  else console.log(...args)
+}
+export const logFatal = (...args) => log(FATAL, ...args)
+export const logError = (...args) => log(ERROR, ...args)
+export const logWarn = (...args) => log(WARN, ...args)
+export const logInfo = (...args) => log(INFO, ...args)
+export const logDebug = (...args) => log(DEBUG, ...args)
+export const logTrace = (...args) => log(TRACE, ...args)
+export const logSilly = (...args) => log(SILLY, ...args)

package/lib/utils/nextTick.js

@@ -0,0 +1,47 @@
+import { logError, logInfo } from './logger.js'
+
+let _tickCount = 0
+let _nextTick
+if (typeof setTimeout !== 'undefined') {
+  _nextTick = setTimeout
+}
+if (typeof process !== 'undefined') {
+  _nextTick = process.nextTick
+}
+
+let _functions = []
+let _handlingTriggered = false
+
+export const nextTick = f => {
+  _functions.push(f)
+  if (_handlingTriggered) return
+  _handlingTriggered = true
+  _nextTick(() => handleNextTick())
+}
+
+export const handleNextTick = (decorate = false) => {
+  ++_tickCount
+  if (decorate) logInfo(() => console.log(`👇👇👇👇👇👇👇👇👇👇 --- _tickCount: ${_tickCount} ---\n\n`))
+  for (let i = 0; i < 10; ++i) {
+    _handlingTriggered = false
+    const __functions = _functions
+    _functions = []
+    __functions.forEach(f => f())
+    if (!_functions.length) {
+      if (decorate) logInfo(() => console.log('\n\n👆👆👆👆👆👆👆👆👆👆 ---'))
+      return
+    }
+    if (decorate) logInfo(() => console.log(`\n\n🤔🤔🤔🤔🤔🤔🤔🤔🤔🤔 --- _tickCount: ${_tickCount} loop: ${i} ---\n\n`))
+  }
+  _tickCount = Math.ceil(_tickCount)
+  logError(() => console.error('handleNextTick adding nextTick handler too many times'))
+}
+
+export const getTickCount = () => _tickCount
+
+export const tics = async (count = 1, ticLabel = '') => {
+  for (let i = 0; i < count; ++i) {
+    if (ticLabel) logInfo(() => console.log(`${ticLabel}, tic: ${i}`))
+    await new Promise(resolve => setTimeout(resolve))
+  }
+}