jostraca 0.18.0 → 0.19.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jostraca",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "main": "dist/jostraca.js",
   "type": "commonjs",
   "types": "dist/jostraca.d.ts",
@@ -35,9 +35,9 @@
   ],
   "devDependencies": {
     "@hapi/code": "^9.0.3",
-    "@types/node": "22.15.17",
-    "esbuild": "^0.25.4",
-    "oxc-parser": "^0.68.1",
+    "@types/node": "22.15.29",
+    "esbuild": "^0.25.5",
+    "oxc-parser": "^0.72.2",
     "typescript": "^5.8.3"
   },
   "peerDependencies": {
@@ -45,7 +45,7 @@
     "memfs": ">=4"
   },
   "dependencies": {
-    "diff": "^7.0.0",
+    "diff": "^8.0.2",
     "gubu": "^9.0.0",
     "node-diff3": "^3.1.2"
   }

package/src/cmp/Fragment.ts

@@ -16,6 +16,7 @@ const FragmentShape = Gubu({
   exclude: Optional(One(Boolean, [String])) as unknown as boolean | string[],
   indent: Optional(One(Empty(String), Number)),
   replace: {} as any,
+  eject: Optional([One(String, RegExp)]) as unknown as any[]
 }, { name: 'Fragment' })
 
 
@@ -74,6 +75,7 @@ const Fragment = cmp(function Fragment(props: FragmentProps, children: any) {
 
   template(src, model, {
     replace,
+    eject: props?.eject,
     handle: (s?: string) => null == s ? null : Content(s)
   })
 })

package/src/jostraca.ts

@@ -49,6 +49,8 @@ import {
 } from './util/basic'
 
 
+import * as PointUtil from './util/point'
+
 // TODO: the actual signatures
 const deep: (...args: any[]) => any = JsonicUtil.deep
 const omap: (...args: any[]) => any = JsonicUtil.omap
@@ -242,7 +244,7 @@ function Jostraca(gopts_in?: JostracaOptions | {}) {
       }
 
       if (memfs) {
-        res.vol = memfs.vol
+        res.vol = () => memfs.vol
       }
 
       return res
@@ -385,6 +387,7 @@ function cmp(component: Function): Component {
 // }
 
 
+
 export type {
   JostracaOptions,
   Component,
@@ -429,6 +432,8 @@ export {
   Line,
   Slot,
   List,
+
+  PointUtil,
 }
 
 

package/src/types.ts

@@ -44,7 +44,7 @@ type JostracaResult = {
     conflicted: string[],
     unchanged: string[],
   }
-  vol?: any
+  vol?: () => any
 }
 
 

package/src/util/basic.ts

@@ -350,12 +350,41 @@ function template(
     ref?: string,
     insert?: RegExp,
     replace?: Record<string, any>,
+    eject?: any[]
     handle?: (s?: string) => void
   },
 ) {
 
   src = null == src ? '' : '' + src
   model = null == model ? {} : model
+
+  let eject = spec?.eject
+  if (null != eject) {
+    const ejectStart: RegExp | null = null == eject[0] ? null :
+      eject[0] instanceof RegExp ? eject[0] :
+        new RegExp('[ \t]*' + escre('' + eject[0]) + '[ \t]*\\n?')
+    const ejectEnd: RegExp | null = null == eject[1] ? null :
+      eject[1] instanceof RegExp ? eject[1] :
+        new RegExp('[ \t]*' + escre('' + eject[1]) + '[ \t]*\\n?')
+
+    if (null != ejectStart && null != ejectEnd) {
+      let startIndex = 0
+      let endIndex = src.length
+
+      const startMatch = src.match(ejectStart)
+      if (startMatch) {
+        startIndex = (startMatch as any).index + startMatch[0].length
+      }
+
+      const endMatch = src.match(ejectEnd)
+      if (endMatch) {
+        endIndex = (endMatch as any).index
+      }
+
+      src = src.substring(startIndex, endIndex)
+    }
+  }
+
   let open = null == spec?.open ? '\\$\\$' : spec.open
   let close = null == spec?.close ? '\\$\\$' : spec.close
   let ref = null == spec?.ref ? '[^$]+' : spec.ref

package/src/util/point.ts

@@ -0,0 +1,296 @@
+
+import { Gubu, Skip, Any } from 'gubu'
+
+import { getx } from './basic'
+
+
+type PointCtx = {
+  async: boolean
+  log: LogEntry[]
+  data: Record<string, any>
+  depth: number,
+  sys: (() => {
+    now: () => number,
+    print: (...s: any) => void
+  }) & { plog?: string[] }
+}
+
+
+type LogEntry = {
+  note: string
+  when: number
+  depth: number
+  args: any
+}
+
+
+abstract class Point implements Point {
+  id: string
+  name?: string
+  args?: any
+
+  constructor(id: string, name?: string) {
+    this.id = id
+    this.name = name
+  }
+
+  async runner(pctx: PointCtx): Promise<void> {
+    const suffix = (null == this.name || '' === this.name) ? '' : ':' + this.name
+    this.logger(pctx, {
+      note: this.constructor.name + ':before:' + this.id + suffix, args: this.args
+    })
+    if (pctx.async) {
+      await this.run(pctx)
+    }
+    else {
+      this.run(pctx)
+    }
+    this.logger(pctx, {
+      note: this.constructor.name + ':after:' + this.id + suffix, args: this.args
+    })
+  }
+
+
+  logger(pctx: PointCtx, entry: Partial<LogEntry>) {
+    entry.note = null == entry.note ? 'none' : entry.note
+    entry.when = pctx.sys().now()
+    entry.depth = pctx.depth
+    if (undefined === entry.args) {
+      delete entry.args
+    }
+    pctx.log.push(entry as LogEntry)
+  }
+
+  abstract run(pctx: PointCtx): Promise<void>
+}
+
+
+class SerialPoint extends Point {
+  points: Point[]
+
+  constructor(id: string) {
+    super(id)
+    this.points = []
+  }
+
+  add(p: Point) {
+    this.points.push(p)
+  }
+
+  async run(pctx: PointCtx): Promise<void> {
+    let childctx: PointCtx = { ...pctx }
+    childctx.depth++
+    for (let p of this.points) {
+      if (pctx.async) {
+        await p.runner(childctx)
+      }
+      else {
+        p.runner(childctx)
+      }
+    }
+  }
+}
+
+
+class RootPoint extends SerialPoint {
+  points: Point[]
+
+  constructor(id: string) {
+    super(id)
+    this.points = []
+  }
+
+  direct(data?: Record<string, any>, sys?: any): PointCtx {
+    const pctx = this.makePointCtx(false, data, sys)
+    this.runner(pctx)
+    return pctx
+  }
+
+  async start(data?: Record<string, any>, sys?: any): Promise<PointCtx> {
+    const pctx = this.makePointCtx(true, data, sys)
+    await this.runner(pctx)
+    return pctx
+  }
+
+
+  makePointCtx(async: boolean, data?: Record<string, any>, sys?: any): PointCtx {
+    const pctx: PointCtx = {
+      async,
+      log: [],
+      data: data || {},
+      depth: 0,
+      sys: sys || (() => ({
+        now: () => Date.now(),
+        print: (...s: any) => {
+          if (null != s[0] && 'string' === typeof s[0]) {
+            console.dir(s[0], s[1] || { depth: null })
+          }
+          else {
+            console.log(...s)
+          }
+        }
+      }))
+    }
+    return pctx
+  }
+}
+
+
+
+class ParallelPoint extends Point {
+  points: Point[]
+
+  constructor(id: string) {
+    super(id)
+    this.points = []
+  }
+
+  add(p: Point) {
+    this.points.push(p)
+  }
+
+  async run(pctx: PointCtx): Promise<void> {
+    let childctx: PointCtx = { ...pctx }
+    childctx.depth++
+    await Promise.all(this.points.map(p => p.runner(childctx)))
+  }
+}
+
+
+
+
+class FuncPoint extends Point {
+  func: (pctx: PointCtx) => any
+
+  constructor(id: string, func: (pctx: PointCtx) => any) {
+    super(id, func.name)
+    this.func = func
+  }
+
+  async run(pctx: PointCtx): Promise<void> {
+    if (pctx.async) {
+      await this.func(pctx)
+    }
+    else {
+      this.func(pctx)
+    }
+  }
+}
+
+
+class PrintPoint extends Point {
+  path?: string
+
+  constructor(id: string, path?: string) {
+    super(id)
+    this.path = path
+  }
+
+  async run(pctx: PointCtx): Promise<void> {
+    let print = pctx.sys().print
+    let d = pctx.data
+    if (null != this.path) {
+      d = getx(d, this.path)
+    }
+
+    if (null != d && 'object' === typeof d) {
+      print('POINTCTX:')
+      print(d)
+    }
+    else {
+      print('POINTCTX: ' + d)
+    }
+  }
+}
+
+
+const PointDefShape = Gubu({
+  k: Skip(String),
+  n: Skip(String),
+  p: Skip([]),
+  a: Any(),
+  m: {}
+})
+
+type PointDef = Partial<ReturnType<typeof PointDefShape>>
+
+type MakePoint = (id: () => string, pdef: PointDef) => Point
+
+
+function buildPoints(pdef: PointDef, pm: Record<string, MakePoint>, id?: () => string): Point {
+  let idi = 0
+  id = id || (() => (++idi) + '')
+  let p: Point | undefined = undefined
+
+  // TODO: fix point kind resolution to be more extensible
+
+  pdef = PointDefShape(pdef)
+  let isSerial = 'Serial' === pdef.k || Array.isArray(pdef.p)
+
+  const mp = pm[pdef.k]
+  if (null != mp) {
+    p = mp(id, pdef)
+  }
+  else if (null == pdef.k || 'Root' === pdef.k) {
+    const rp = new RootPoint(id())
+    let cp = pdef.p
+    for (let c of cp) {
+      rp.add(buildPoints(c, pm, id))
+    }
+    p = rp
+    isSerial = false
+  }
+  else if ('Parallel' === pdef.k) {
+    const sp = new ParallelPoint(id())
+    let cp = pdef.p
+    for (let c of cp) {
+      sp.add(buildPoints(c, pm, id))
+    }
+    p = sp
+    isSerial = false
+  }
+
+  if (isSerial) {
+    const sp = (p || new SerialPoint(id())) as SerialPoint
+    let cp = pdef.p
+    for (let c of cp) {
+      sp.add(buildPoints(c, pm, id))
+    }
+    p = sp
+  }
+
+  if (null == p) {
+    throw new Error('Unknown point kind: ' + JSON.stringify(pdef))
+  }
+
+  return p
+}
+
+
+function makeFuncDef(fd: (pdef: PointDef) => (pctx: PointCtx) => any) {
+  return (id: () => string, pdef: PointDef) => {
+    const fp = new FuncPoint(id(), fd(pdef))
+    fp.args = pdef.a
+    return fp
+  }
+}
+
+
+
+export type {
+  PointCtx,
+  MakePoint,
+  PointDef,
+}
+
+
+export {
+  Point,
+  RootPoint,
+  SerialPoint,
+  ParallelPoint,
+  FuncPoint,
+  PrintPoint,
+  buildPoints,
+  makeFuncDef,
+}