jostraca 0.4.0 → 0.6.0

package/src/op/CopyOp.ts

@@ -0,0 +1,229 @@
+
+import Path from 'node:path'
+
+import type { Node } from '../jostraca'
+
+import { getx } from '../jostraca'
+
+import { FileOp } from './FileOp'
+
+
+const CopyOp = {
+
+  before(node: Node, ctx$: any, buildctx: any) {
+    const fs = buildctx.fs
+
+    // TODO: do these need null checks here?
+    const name = node.name as string
+    const from = node.from as string
+
+    const fromStat = fs.statSync(from)
+
+    if (fromStat.isFile()) {
+      FileOp.before(node, ctx$, buildctx)
+      const topath = buildctx.current.file.path
+      const state = {
+        fileCount: 0,
+        folderCount: 0,
+        tmCount: 0,
+        ctx$,
+        buildctx,
+      }
+      const spec = { name, frompath: from, topath }
+
+      let content = processTemplate(state, fs.readFileSync(from).toString(), spec)
+
+      buildctx.current.file.content.push(content)
+      node.after = node.after || {}
+      node.after.kind = 'file'
+    }
+
+    else if (fromStat.isDirectory()) {
+      if (null != from && '' != from) {
+        node.after = node.after || {}
+        node.after.kind = 'copy'
+      }
+    }
+
+    else {
+      throw new Error('Unable to process file: ' + from)
+    }
+  },
+
+
+  after(node: Node, ctx$: any, buildctx: any) {
+    const info = buildctx.info
+    const kind = node.after.kind
+
+    const frompath = node.from as string
+    const topath = buildctx.current.folder.path.join('/')
+
+    let exclude = node.exclude
+    if (info && true === exclude) {
+      return
+    }
+
+    if ('file' === kind) {
+      FileOp.after(node, ctx$, buildctx)
+    }
+    else if ('copy' === kind) {
+      const state = {
+        fileCount: 0,
+        folderCount: 0,
+        tmCount: 0,
+        ctx$,
+        buildctx,
+      }
+
+      // TODO: node.path is wrong
+      // change prop.name to prop.to and account for subfolders
+
+      walk(state, node.path, frompath, topath)
+    }
+    else {
+      throw new Error('Unknown kind=' + kind + ' for file: ' + frompath)
+    }
+  },
+
+}
+
+
+function walk(state: any, nodepath: string[], from: string, to: string) {
+  const buildctx = state.buildctx
+  const fs = buildctx.fs
+  const entries = fs.readdirSync(from)
+
+  for (let name of entries) {
+    const frompath = Path.join(from, name)
+    const topath = Path.join(to, name)
+    const stat = fs.statSync(frompath)
+
+    if (stat.isDirectory()) {
+      state.folderCount++
+      walk(state, nodepath.concat(name), frompath, topath)
+    }
+    else if (isTemplate(name)) {
+      if (excludeFile(state, nodepath, name, topath)) { continue }
+      const src = fs.readFileSync(frompath, 'utf8')
+      const out = genTemplate(state, src, { name, frompath, topath })
+      writeFileSync(buildctx, topath, out)
+      state.fileCount++
+      state.tmCount++
+    }
+    else {
+      if (excludeFile(state, nodepath, name, topath)) { continue }
+      copyFileSync(buildctx, frompath, topath)
+      state.fileCount++
+    }
+  }
+}
+
+
+function excludeFile(state: any, nodepath: string[], name: string, frompath: string) {
+  const { fs, info } = state.buildctx
+  let exclude = false
+
+  // NOT Path.sep - needs to be canonical
+  const rpath = nodepath.concat(name).join('/')
+
+  if (info) {
+    exclude = info.exclude.includes(rpath)
+    let stat, timedelta
+    if (!exclude) {
+      stat = fs.statSync(frompath, { throwIfNoEntry: false })
+      if (stat) {
+        timedelta = stat.mtimeMs - info.last
+        if (stat && (timedelta > 0 && timedelta < stat.mtimeMs)) {
+          exclude = true
+        }
+      }
+    }
+
+    // if ('sdk.js' === name) {
+    // console.log('COPYSTAT', rpath, frompath,
+    //   timedelta,
+    //   info.exclude.includes(rpath),
+    //   stat?.mtimeMs - info.last,
+    //   stat?.mtimeMs, info.last, exclude)
+    // }
+  }
+
+  if (exclude && info && !info.exclude.includes(rpath)) {
+    // NOT Path.sep - has to be canonical
+    info.exclude.push(rpath)
+  }
+
+  // console.log('COPY-EXCLUDE', rpath, exclude)
+  return exclude
+}
+
+
+function writeFileSync(buildctx: any, path: string, content: string) {
+  // console.log('WF', path)
+  const fs = buildctx.fs
+  // TODO: check excludes
+  fs.mkdirSync(Path.dirname(path), { recursive: true })
+  fs.writeFileSync(path, content, 'utf8')
+}
+
+
+function copyFileSync(buildctx: any, frompath: string, topath: string) {
+  const fs = buildctx.fs
+  // TODO: check excludes
+  fs.mkdirSync(Path.dirname(topath), { recursive: true })
+  fs.copyFileSync(frompath, topath)
+}
+
+
+function processTemplate(
+  state: any,
+  src: any,
+  spec: { name: string, frompath: string, topath: string }) {
+  if (isTemplate(spec.name)) {
+    return genTemplate(state, src, spec)
+  }
+  return src
+}
+
+function isTemplate(name: string) {
+  // TODO: need a better way; alsp should be configurable
+  return !name.match(/\.(gif|jpe?g|png|ico|bmp|tiff)$/i)
+}
+
+// NOTE: $$foo.bar$$ format used as explicit start and end markers mean regex can be used
+// unambiguously ($fooa would not match `foo`)
+function genTemplate(
+  state: any,
+  src: any,
+  spec: { name: string, frompath: string, topath: string }) {
+
+  let model = state.ctx$.model // { foo: 'FOO', bar: 'BAR' }
+  let out = ''
+  let remain = src
+  let nextm = true
+  while (nextm) {
+    let m = remain.match(/\$\$([^$]+)\$\$/)
+    if (m) {
+      let ref = m[1]
+      out += remain.substring(0, m.index)
+      let insert = getx(model, ref)
+      if (null == insert) {
+        out += '$$' + ref + '$$'
+        remain = remain.substring(m.index + 4 + ref.length)
+      }
+      else {
+        out += insert
+        remain = remain.substring(m.index + 4 + ref.length)
+      }
+    }
+    else {
+      out += remain
+      nextm = false
+    }
+  }
+  return out
+}
+
+export {
+  CopyOp
+}

package/src/op/FileOp.ts

@@ -0,0 +1,58 @@
+
+import Path from 'node:path'
+
+import type { Node } from '../jostraca'
+
+
+const FileOp = {
+
+  before(node: Node, _ctx$: any, buildctx: any) {
+    const cfile: any = buildctx.current.file = node
+    cfile.filepath = buildctx.current.folder.path.join('/') + '/' + node.name
+    cfile.content = []
+  },
+
+
+  after(node: Node, _ctx$: any, buildctx: any) {
+    // console.log('FB-INFO', buildctx.info)
+
+    const { fs, info, current } = buildctx
+    const cfile = current.file
+    const content = cfile.content.join('')
+    const rpath = cfile.path.join('/') // NOT Path.sep - needs to be canonical
+    let exclude = node.exclude
+
+    // console.log('FILE-a exclude', rpath, exclude, !!info)
+
+    if (info && null == exclude) {
+      exclude = info.exclude.includes(rpath)
+      if (!exclude) {
+        const stat = fs.statSync(cfile.filepath, { throwIfNoEntry: false })
+        if (stat) {
+          let timedelta = stat.mtimeMs - info.last
+          if ((timedelta > 0 && timedelta < stat.mtimeMs)) {
+            exclude = true
+          }
+          // console.log('STAT', rpath, timedelta, exclude, stat?.mtimeMs, info.last)
+        }
+      }
+    }
+
+    // console.log('FILE-a write', rpath, exclude) // , content.substring(0, 111))
+
+    if (!exclude) {
+      fs.writeFileSync(cfile.filepath, content)
+    }
+    else {
+      if (!info.exclude.includes(rpath)) {
+        info.exclude.push(rpath)
+      }
+    }
+  },
+
+}
+
+
+export {
+  FileOp
+}

package/src/op/FolderOp.ts

@@ -0,0 +1,31 @@
+
+import Path from 'node:path'
+
+import type { Node } from '../jostraca'
+
+
+const FolderOp = {
+
+  before(node: Node, _ctx$: any, buildctx: any) {
+    const cfolder = buildctx.current.folder = (buildctx.current.folder || {})
+
+    cfolder.node = node
+    cfolder.path = (cfolder.path || [buildctx.current.folder.parent])
+    cfolder.path.push(node.name)
+
+    let fullpath = cfolder.path.join(Path.sep)
+    buildctx.fs.mkdirSync(fullpath, { recursive: true })
+  },
+
+
+  after(_node: Node, _ctx$: any, buildctx: any) {
+    const cfolder = buildctx.current.folder
+    cfolder.path.length = cfolder.path.length - 1
+  },
+
+}
+
+
+export {
+  FolderOp
+}

package/src/op/NoneOp.ts

@@ -0,0 +1,14 @@
+
+
+import type { Node } from '../jostraca'
+
+
+const NoneOp = {
+  before(node: Node, _ctx$: any, buildctx: any) { },
+  after(_node: Node, _ctx$: any, buildctx: any) { },
+}
+
+
+export {
+  NoneOp
+}

package/src/op/ProjectOp.ts

@@ -0,0 +1,33 @@
+
+import Path from 'node:path'
+
+import type { Node } from '../jostraca'
+
+
+const ProjectOp = {
+
+  before(node: Node, ctx$: any, buildctx: any) {
+    // console.log('PROJECT-B', node.folder, ctx$.folder)
+
+    node.folder = null == node.folder || '' === node.folder ? '.' : node.folder
+    node.folder = Path.isAbsolute(node.folder) ? node.folder : Path.join(ctx$.folder, node.folder)
+
+    // console.log('PROJECT-B folder', node.folder)
+
+    buildctx.current.project = { node }
+    buildctx.current.folder = {
+      node,
+      path: node.folder.split(Path.sep),
+    }
+
+    buildctx.fs.mkdirSync(node.folder, { recursive: true })
+  },
+
+  after(_node: Node, _ctx$: any, _buildctx: any) { },
+
+}
+
+
+export {
+  ProjectOp
+}

package/src/utility.ts

@@ -0,0 +1,306 @@
+/* Copyright (c) 2024 Richard Rodger, MIT License */
+
+
+type JostracaOptions = {
+  folder?: string
+  fs?: any
+  meta?: any
+}
+
+
+type Node = {
+  kind: string
+  children?: Node[]
+  name?: string
+  path: string[]
+  from?: string
+  content?: any[]
+  folder?: string
+  after?: any
+  exclude?: boolean
+}
+
+
+type OpStep = (node: Node, ctx$: any, buildctx: any) => void
+
+type OpDef = {
+  before: OpStep,
+  after: OpStep,
+}
+
+
+type Component = (props: any, children?: any) => void
+
+
+
+
+function each(subject?: any, apply?: any) {
+  if (null == apply) {
+    let out = []
+    if (Array.isArray(subject)) {
+      for (let fn of subject) {
+        out.push('function' === typeof fn ? fn() : fn)
+      }
+      return out.sort()
+    }
+    else if (null == subject || 'object' !== typeof subject) {
+      return []
+    }
+  }
+  else if (Array.isArray(subject)) {
+    return subject.map(apply)
+  }
+
+  if (null == subject || 'object' !== typeof subject) {
+    return []
+  }
+
+  const entries: any = Object.entries(subject).map((n: any[], _: any) =>
+  (_ = typeof n[1],
+    (null != n[1] && 'object' === _) ? (n[1].key$ = n[0]) :
+      (n[1] = { name: n[0], key$: n[0], val$: n[1] }), n))
+
+  if (1 < entries.length) {
+    if (entries[0] && entries[0][1] && 'string' === typeof entries[0][1].name) {
+      entries.sort((a: any, b: any) =>
+        a[1].name < b[1].name ? -1 : b[1].name < a[1].name ? 1 : 0)
+    }
+    else if (entries[0] && entries[0][1] && 'string' === typeof entries[0][1].key$) {
+      entries.sort((a: any, b: any) =>
+        a[1].key$ < b[1].key$ ? -1 : b[1].key$ < a[1].key$ ? 1 : 0)
+    }
+  }
+
+  apply = 'function' === typeof apply ? apply : (x: any) => x
+
+  return entries.map((n: any, ...args: any[]) =>
+    apply(n[1], n[0], ...args))
+}
+
+
+
+function select(key: any, map: Record<string, Function>) {
+  const fn = map && map[key]
+  return fn ? fn() : undefined
+}
+
+
+
+function getx(root: any, path: string | string[]): any {
+  path = ('string' === typeof path ? path.split(/[.\s\r\n\t]/) : path).filter(part => '' != part)
+  let node = root
+  let parents = []
+
+  partloop:
+  for (let i = 0; i < path.length && null != node; i++) {
+    let part = String(path[i]).trim()
+
+    if ('*' === part) {
+      // console.log('STAR', each(node), path.slice(i + 1))
+      return getx(each(node), path.slice(i + 1))
+    }
+
+    let m = part.match(/^([^<=>~^?!]*)([<=>~^?!]+)(.*)$/)
+
+    if (m) {
+      part = m[1]
+      let op = m[2]
+      let arg: any = m[3]
+
+      let val = '' === part ? node : node[part]
+
+      const argtype = typeof arg
+      arg =
+        'true' === arg ? true :
+          'false' === arg ? false :
+            'string' === argtype ?
+              (arg.match(/^"[^"]+"$/) ? arg.substring(1, arg.length - 1) : arg) : arg
+
+      // console.log('GETX-M', val, part, op, arg)
+
+      if ('=' === op && 'null' === arg) {
+        parents.push(node)
+        node = {} // virtual node so that ^ works consistently
+        continue partloop
+      }
+      else if ('^' === op && '' === part && '' !== arg) {
+        node = parents[parents.length - Number(arg)]
+        continue partloop
+      }
+      else if ('?' === op[0]) {
+        // no property name
+        arg = (1 < op.length ? op.substring(1) : '') + arg
+
+        node = Array.isArray(val) ?
+          each(val).filter((n: any) => (
+            null != getx(n, arg))) :
+          each(val).filter((n: any) => (
+            null != getx(n, arg)))
+            .reduce((a: any, n: any) => (a[n.key$] = n, delete n.key$, a), {})
+
+        continue partloop
+      }
+
+      if (null == val) return undefined
+
+      // const valtype = typeof val
+
+      val = Array.isArray(val) ? val.length :
+        'object' === typeof val ? Object.keys(val).filter(k => !k.includes('$')).length :
+          val
+
+      switch (op) {
+        case '<':
+          if (!(val < arg)) return undefined
+          break
+        case '<=':
+          if (!(val <= arg)) return undefined
+          break
+        case '>':
+          if (!(val > arg)) return undefined
+          break
+        case '>=':
+          if (!(val >= arg)) return undefined
+          break
+        case '=':
+          if (!(val == arg)) return undefined
+          break
+        case '==':
+          if (!(val === arg)) return undefined
+          break
+        case '!=':
+          if (!(val != arg)) return undefined
+          break
+        case '~':
+          if (!(String(val).match(RegExp(arg)))) return undefined
+          break
+        case '^':
+          node = parents[parents.length - Number(arg)]
+          continue partloop
+        default:
+          return undefined
+      }
+    }
+
+    parents.push(node)
+    node = '' === part ? node : node[part]
+  }
+  return node
+}
+
+
+function get(root: any, path: string | string[]): any {
+  path = 'string' === typeof path ? path.split('.') : path
+  let node = root
+  for (let i = 0; i < path.length && null != node; i++) {
+    node = node[path[i]]
+  }
+  return node
+}
+
+
+function camelify(input: any[] | string) {
+  let parts = 'string' == typeof input ? input.split('-') : input.map(n => '' + n)
+  return parts
+    .map((p: string) => ('' === p ? '' : (p[0].toUpperCase() + p.substring(1))))
+    .join('')
+}
+
+
+function kebabify(input: any[] | string) {
+  let parts = 'string' == typeof input ? input.split(/([A-Z])/) : input.map(n => '' + n)
+  return parts
+    .filter((p: string) => '' !== p)
+    .reduce((a: any[], n: string, i: number) =>
+      ((0 === i % 2 ? a.push(n.toLowerCase()) : a[(i / 2) | 0] += n), a), [])
+    .join('-')
+}
+
+
+function snakify(input: any[] | string) {
+  let parts = 'string' == typeof input ? input.split(/([A-Z])/) : input.map(n => '' + n)
+  return parts
+    .filter((p: string) => '' !== p)
+    .reduce((a: any[], n: string, i: number) =>
+      ((0 === i % 2 ? a.push(n.toLowerCase()) : a[(i / 2) | 0] += n), a), [])
+    .join('_')
+}
+
+
+function names(base: any, name: string, prop = 'name') {
+  base.name$ = name
+  base[prop.toLowerCase()] = name.toLowerCase()
+  base[camelify(prop)] = camelify(name)
+  base[snakify(prop)] = snakify(name)
+  base[kebabify(prop)] = kebabify(name)
+  base[prop.toUpperCase()] = name.toUpperCase()
+}
+
+
+
+// Map child objects to new child objects
+function cmap(o: any, p: any) {
+  return Object
+    .entries(o)
+    .reduce((r: any, n: any, _: any) => (_ = Object
+      .entries(p)
+      .reduce((s: any, m: any) => (cmap.FILTER === s ? s : (s[m[0]] = (
+        // transfom(val,key,current,parentkey,parent)
+        'function' === typeof m[1] ? m[1](n[1][m[0]], {
+          skey: m[0], self: n[1], key: n[0], parent: o
+        }) : m[1]
+      ), (cmap.FILTER === s[m[0]] ? cmap.FILTER : s))), {})
+      , (cmap.FILTER === _ ? 0 : r[n[0]] = _), r), {})
+}
+
+cmap.COPY = (x: any) => x
+// keep self if x is truthy, or function returning truthy-new-value or [truthy,new-value]
+cmap.FILTER = (x: any) => 'function' === typeof x ? ((y: any, p: any, _: any) =>
+  (_ = x(y, p), Array.isArray(_) ? !_[0] ? _[1] : cmap.FILTER : _)) : (x ? x : cmap.FILTER)
+cmap.KEY = (_: any, p: any) => p.key
+
+
+// Map child objects to a list of child objects
+function vmap(o: any, p: any) {
+  return Object
+    .entries(o)
+    .reduce((r: any, n: any, _: any) => (_ = Object
+      .entries(p)
+      .reduce((s: any, m: any) => (vmap.FILTER === s ? s : (s[m[0]] = (
+        // transfom(val,key,current,parentkey,parent)
+        // 'function' === typeof m[1] ? m[1](n[1][m[0]], m[0], n[1], n[0], o) : m[1]
+        'function' === typeof m[1] ? m[1](n[1][m[0]], {
+          skey: m[0], self: n[1], key: n[0], parent: o
+        }) : m[1]
+      ), (vmap.FILTER === s[m[0]] ? vmap.FILTER : s))), {})
+      , (vmap.FILTER === _ ? 0 : r.push(_)), r), [])
+
+}
+vmap.COPY = (x: any) => x
+vmap.FILTER = (x: any) => 'function' === typeof x ? ((y: any, p: any, _: any) =>
+  (_ = x(y, p), Array.isArray(_) ? !_[0] ? _[1] : vmap.FILTER : _)) : (x ? x : vmap.FILTER)
+vmap.KEY = (_: any, p: any) => p.key
+
+
+
+export type {
+  JostracaOptions,
+  Node,
+  OpStep,
+  OpDef,
+  Component,
+}
+
+
+export {
+  each,
+  select,
+  get,
+  getx,
+  camelify,
+  snakify,
+  kebabify,
+  cmap,
+  vmap,
+  names,
+}