jostraca 0.5.0 → 0.7.0

package/src/jostraca.ts

@@ -1,44 +1,46 @@
 /* Copyright (c) 2024 Richard Rodger, MIT License */
 
 import * as Fs from 'node:fs'
+import Path from 'node:path'
 
 import { AsyncLocalStorage } from 'node:async_hooks'
 
-import { Copy } from './cmp/Copy'
-
-import { CopyOp } from './op/CopyOp'
-
-import { util as JostracaUtil } from '@jsonic/jsonic-next'
-
-const { deep } = JostracaUtil
-
-
-type JostracaOptions = {
-  folder?: string
-  fs?: any
-  meta?: any
-}
 
+import type {
+  JostracaOptions,
+  Node,
+  OpDef,
+  Component,
+} from './utility'
 
-type Node = {
-  kind: string
-  children?: Node[]
-  name?: string
-  path?: string
-  from?: string
-  content?: any[]
-}
 
+import {
+  each,
+  select,
+  get,
+  getx,
+  camelify,
+  snakify,
+  kebabify,
+  cmap,
+  vmap,
+  names,
+} from './utility'
 
-type OpStep = (node: Node, ctx$: any, buildctx: any) => void
 
-type OpDef = {
-  before: OpStep,
-  after: OpStep,
-}
+import { Content } from './cmp/Content'
+import { Copy } from './cmp/Copy'
+import { File } from './cmp/File'
+import { Folder } from './cmp/Folder'
+import { Project } from './cmp/Project'
 
+import { CopyOp } from './op/CopyOp'
+import { ProjectOp } from './op/ProjectOp'
+import { FolderOp } from './op/FolderOp'
+import { FileOp } from './op/FileOp'
+import { ContentOp } from './op/ContentOp'
+import { NoneOp } from './op/NoneOp'
 
-type Component = (props: any, children?: any) => void
 
 
 const GLOBAL = (global as any)
@@ -49,38 +51,40 @@ function Jostraca() {
   GLOBAL.jostraca = new AsyncLocalStorage()
 
 
-  function generate(opts: JostracaOptions, root: Function) {
+  async function generate(opts: JostracaOptions, root: Function) {
     const fs = opts.fs || Fs
     const meta = opts.meta || {}
     const folder = opts.folder || '.'
 
     const ctx$ = {
-      fs,
       folder,
       content: null,
       meta,
+      fs,
     }
 
-    GLOBAL.jostraca.run(ctx$, () => {
+    return GLOBAL.jostraca.run(ctx$, async () => {
       try {
-        // console.log('START ROOT')
+        // Define phase
         root()
-        // console.log('END ROOT')
 
         const ctx$ = GLOBAL.jostraca.getStore()
 
-        // console.log('START BUILD')
-        build(
-          ctx$,
-          {
-            fs,
-            current: {
-              folder: {
-                parent: folder
-              }
+        // console.dir(ctx$.node, { depth: null })
+
+        // Build phase
+
+        const buildctx = {
+          fs,
+          folder,
+          current: {
+            folder: {
+              parent: folder
             }
-          })
-        // console.log('END BUILD')
+          }
+        }
+        await build(ctx$, buildctx)
+        return buildctx
       }
       catch (err: any) {
         console.log('JOSTRACA ERROR:', err)
@@ -90,101 +94,80 @@ function Jostraca() {
   }
 
 
-  function build(ctx$: any, buildctx: any) {
+  async function build(ctx$: any, buildctx: any) {
     const topnode = ctx$.node
-    step(topnode, ctx$, buildctx)
-  }
 
+    let info = { exclude: [], last: -1 }
+    const infopath = Path.join(buildctx.folder, '.jostraca', 'info.json')
 
-  function step(node: Node, ctx$: any, buildctx: any) {
-    const op = opmap[node.kind]
-    if (null == op) {
-      throw new Error('missing op: ' + node.kind)
+    try {
+      info = JSON.parse(ctx$.fs.readFileSync(
+        infopath, 'utf8'))
     }
-
-    op.before(node, ctx$, buildctx)
-
-    if (node.children) {
-      for (let childnode of node.children) {
-        step(childnode, ctx$, buildctx)
-      }
+    catch (err: any) {
+      // console.log(err)
+      // TODO: file not foound ignored, handle others!
     }
 
-    op.after(node, ctx$, buildctx)
-  }
-
-
-  const opmap: Record<string, OpDef> = {
-
-    project: {
-      before(node: Node, _ctx$: any, buildctx: any) {
-        const cproject: any = buildctx.current.project = (buildctx.current.project || {})
-        cproject.node = node
-      },
-
-      after(_node: Node, _ctx$: any, _buildctx: any) {
+    buildctx.info = info
+    // console.log('B-INFO', buildctx.info)
 
-      },
-    },
+    await step(topnode, ctx$, buildctx)
 
 
-    folder: {
-      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('/')
-        buildctx.fs.mkdirSync(fullpath, { recursive: true })
-      },
-
+    try {
+      ctx$.fs.mkdirSync(Path.dirname(infopath), { recursive: true })
+      const info = {
+        last: Date.now(),
+        exclude: buildctx.info.exclude,
+      }
+      ctx$.fs.writeFileSync(infopath, JSON.stringify(info, null, 2), { flush: true })
+    }
+    catch (err: any) {
+      console.log(err)
+      // TODO: file not foound ignored, handle others!
+    }
 
-      after(_node: Node, _ctx$: any, buildctx: any) {
-        const cfolder = buildctx.current.folder
-        cfolder.path.length = cfolder.path.length - 1
-      },
-    },
 
+    return { node: topnode, ctx$, buildctx }
+  }
 
-    file: {
-      before(node: Node, _ctx$: any, buildctx: any) {
-        const cfile = buildctx.current.file = node
-        cfile.path = buildctx.current.folder.path.join('/') + '/' + node.name
-        cfile.content = []
-      },
 
-      after(_node: Node, _ctx$: any, buildctx: any) {
-        const cfile = buildctx.current.file
-        const content = cfile.content.join('')
-        buildctx.fs.writeFileSync(cfile.path, content)
-      },
-    },
+  async function step(node: Node, ctx$: any, buildctx: any) {
+    try {
+      const op = opmap[node.kind]
+      if (null == op) {
+        throw new Error('missing op: ' + node.kind)
+      }
 
+      await op.before(node, ctx$, buildctx)
 
-    content: {
-      before(node: Node, _ctx$: any, buildctx: any) {
-        const content = buildctx.current.content = node
-        buildctx.current.file.content.push(content.content)
-      },
+      if (node.children) {
+        for (let childnode of node.children) {
+          await step(childnode, ctx$, buildctx)
+        }
+      }
 
-      after(_node: Node, _ctx$: any, buildctx: any) {
-      },
-    },
+      await op.after(node, ctx$, buildctx)
+    }
+    catch (err: any) {
+      if (err.jostraca) {
+        throw err
+      }
+      err.jostraca = true
+      err.step = node.kind
+      throw err
+    }
+  }
 
 
+  const opmap: Record<string, OpDef> = {
+    project: ProjectOp,
+    folder: FolderOp,
+    file: FileOp,
+    content: ContentOp,
     copy: CopyOp,
-
-
-    none: {
-      before(_node: Node, _ctx$: any, buildctx: any) {
-      },
-
-      after(_node: Node, _ctx$: any, buildctx: any) {
-      },
-    },
-
+    none: NoneOp,
   }
 
 
@@ -194,41 +177,6 @@ function Jostraca() {
 }
 
 
-const Code = cmp(function Code(props: any) {
-  props.ctx$.node.kind = 'content'
-  let src = props.arg
-  props.ctx$.node.content = src
-})
-
-
-const File = cmp(function File(props: any, children: any) {
-  props.ctx$.node.kind = 'file'
-  props.ctx$.node.name = props.name
-
-  // Code('// FILE START: ' + props.name + '\n')
-
-  each(children)
-
-  // Code('// FILE END: ' + props.name + '\n')
-})
-
-
-const Project: Component = cmp(function Project(props: any, children: any) {
-  props.ctx$.node.kind = 'project'
-  props.ctx$.node.name = props.name
-
-  each(children)
-})
-
-
-const Folder = cmp(function Folder(props: any, children: any) {
-  props.ctx$.node.kind = 'folder'
-  props.ctx$.node.name = props.name
-
-  each(children)
-})
-
-
 function cmp(component: Function): Component {
   const cf = (props: any, children?: any) => {
     props = props || {}
@@ -238,9 +186,10 @@ function cmp(component: Function): Component {
     props.ctx$ = GLOBAL.jostraca.getStore()
     children = 'function' === typeof children ? [children] : children
 
-    let node = {
+    let node: Node = {
       kind: 'none',
-      children: []
+      children: [],
+      path: [],
     }
 
     const parent = props.ctx$.node = (props.ctx$.node || node)
@@ -250,6 +199,13 @@ function cmp(component: Function): Component {
     props.ctx$.children = node.children
     props.ctx$.node = node
 
+    node.path = parent.path.slice(0)
+    if ('string' === typeof props.name) {
+      node.path.push(props.name)
+      // console.log('CMP-PATH', component.name, node.path)
+      // console.trace()
+    }
+
     let out = component(props, children)
 
     props.ctx$.children = siblings
@@ -262,233 +218,6 @@ function cmp(component: Function): Component {
 }
 
 
-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()
-    let m = part.match(/^([^<=>~^?!]*)([<=>~^?!]+)(.*)$/)
-
-    if (m) {
-      part = m[1]
-      let op = m[2]
-      let arg = m[3]
-
-      let val = '' === part ? node : node[part]
-
-      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]) {
-        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
-
-      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 (!(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 {
@@ -514,8 +243,9 @@ export {
   names,
 
   Project,
-  Code,
+  Content,
   File,
   Folder,
   Copy,
 }
+

package/src/op/ContentOp.ts

@@ -0,0 +1,18 @@
+
+
+import type { Node } from '../jostraca'
+
+
+const ContentOp = {
+  before(node: Node, _ctx$: any, buildctx: any) {
+    const content = buildctx.current.content = node
+    buildctx.current.file.content.push(content.content)
+  },
+
+  after(_node: Node, _ctx$: any, buildctx: any) { },
+}
+
+
+export {
+  ContentOp
+}