rip-lang 3.13.136 → 3.14.0

package/src/ui.rip

@@ -30,32 +30,35 @@ export { setContext, getContext, hasContext }
 #
 # Wraps a plain object in a Proxy that lazily creates fine-grained signals
 # for each property. Nested objects are wrapped recursively. Supports path-
-# based access via get/set methods (e.g., stash.get('users[0].name')).
+# based bracket access (e.g., app['data/theme/title']) and 7 reserved methods
+# for atomic/structural operations: inc, dec, flip, join, keys, has, del.
 # ==============================================================================
 
-STASH     = Symbol('stash')
-SIGNALS   = Symbol('signals')
-RAW       = Symbol('raw')
-PERSISTED = Symbol('persisted')
 PROXIES   = new WeakMap()
+METHODS   = new WeakMap()
 
 _keysVersion = 0
 _writeVersion = __state(0)
+_depth = 0
+
+isPathKey = (prop) -> typeof prop is 'string' and (prop.indexOf('.') isnt -1 or prop.indexOf('/') isnt -1 or prop.indexOf('[') isnt -1)
+
+isNum = (val) -> /^-?\d+$/.test val
 
 getSignal = (target, prop) ->
-  unless target[SIGNALS]
-    Object.defineProperty target, SIGNALS, { value: new Map(), enumerable: false }
-  sig = target[SIGNALS].get(prop)
+  unless target[:signals]
+    Object.defineProperty target, :signals, { value: new Map(), enumerable: false }
+  sig = target[:signals].get(prop)
   unless sig
     sig = __state(target[prop])
-    target[SIGNALS].set(prop, sig)
+    target[:signals].set(prop, sig)
   sig
 
-keysSignal = (target) -> getSignal(target, Symbol.for('keys'))
+keysSignal = (target) -> getSignal(target, :keys)
 
 wrapDeep = (value) ->
   return value unless value? and typeof value is 'object'
-  return value if value[STASH]
+  return value if value[:stash]
   return value if value instanceof Date or value instanceof RegExp or value instanceof Map or value instanceof Set or value instanceof Promise
   existing = PROXIES.get(value)
   return existing if existing
@@ -65,17 +68,19 @@ makeProxy = (target) ->
   proxy = null
   handler =
     get: (target, prop) ->
-      return true if prop is STASH
-      return target if prop is RAW
+      return true if prop is :stash
+      return target if prop is :raw
       return Reflect.get(target, prop) if typeof prop is 'symbol'
 
       if prop is 'length' and Array.isArray(target)
         keysSignal(target).value
         return target.length
 
-      # Stash API methods
-      return ((path) -> stashGet(proxy, path)) if prop is 'get'
-      return ((path, val) -> stashSet(proxy, path, val)) if prop is 'set'
+      if not _depth and isPathKey(prop)
+        return stashGet(proxy, prop)
+
+      fn = stashMethodFn(proxy, prop)
+      return fn if fn
 
       sig = getSignal(target, prop)
       val = sig.value
@@ -84,13 +89,17 @@ makeProxy = (target) ->
       val
 
     set: (target, prop, value) ->
+      if not _depth and isPathKey(prop)
+        stashSet(proxy, prop, value)
+        return true
+
       old = target[prop]
-      r = if value?[RAW] then value[RAW] else value
+      r = if value?[:raw] then value[:raw] else value
       return true if r is old
       target[prop] = r
 
-      if target[SIGNALS]?.has(prop)
-        target[SIGNALS].get(prop).value = r
+      if target[:signals]?.has(prop)
+        target[:signals].get(prop).value = r
       if old is undefined and r isnt undefined
         keysSignal(target).value = ++_keysVersion
       _writeVersion.value++
@@ -99,9 +108,10 @@ makeProxy = (target) ->
 
     deleteProperty: (target, prop) ->
       delete target[prop]
-      sig = target[SIGNALS]?.get(prop)
+      sig = target[:signals]?.get(prop)
       sig?.value = undefined
       keysSignal(target).value = ++_keysVersion
+      _writeVersion.value++
       true
 
     ownKeys: (target) ->
@@ -133,35 +143,126 @@ walk = (path) ->
     i += 2
   result
 
+resolveIndex = (seg, obj) ->
+  if typeof seg is 'number' and seg < 0
+    t = raw(obj)
+    return t.length + seg if Array.isArray(t)
+  seg
+
 stashGet = (proxy, path) ->
   segs = walk(path)
   obj = proxy
-  for seg in segs
-    return undefined unless obj?
-    obj = obj[seg]
-  obj
+  _depth++
+  try
+    for seg in segs
+      return undefined unless obj?
+      obj = obj[resolveIndex(seg, obj)]
+    obj
+  finally
+    _depth--
 
 stashSet = (proxy, path, value) ->
   segs = walk(path)
   obj = proxy
-  for seg, i in segs
-    if i is segs.length - 1
-      obj[seg] = value
-    else
-      obj[seg] = {} unless obj[seg]?
-      obj = obj[seg]
-  value
+  _depth++
+  try
+    for seg, i in segs
+      key = resolveIndex(seg, obj)
+      if i is segs.length - 1
+        obj[key] = value
+      else
+        unless obj[key]?
+          nextSeg = segs[i + 1]
+          obj[key] = if typeof nextSeg is 'number' or isNum(nextSeg) then [] else {}
+        obj = obj[key]
+    value
+  finally
+    _depth--
+
+# Stash methods — reserved names for atomic/structural operations
+STASH_METHOD_NAMES = { inc: true, dec: true, flip: true, join: true, keys: true, has: true, del: true }
+
+stashMethodFn = (proxy, prop) ->
+  return undefined unless STASH_METHOD_NAMES[prop]
+  cache = METHODS.get(proxy)
+  unless cache
+    cache = {}
+    METHODS.set(proxy, cache)
+  return cache[prop] if cache[prop]
+  fn = switch prop
+    when 'inc'  then (path, step = 1) -> cur = stashGet(proxy, path) ?? 0; stashSet(proxy, path, cur + step)
+    when 'dec'  then (path, step = 1) -> cur = stashGet(proxy, path) ?? 0; stashSet(proxy, path, cur - step)
+    when 'flip' then (path) -> cur = stashGet(proxy, path) ?? false; stashSet(proxy, path, not cur)
+    when 'join' then (path, obj) ->
+      __batch ->
+        target = stashGet(proxy, path)
+        unless target? and typeof target is 'object'
+          stashSet(proxy, path, {})
+          target = stashGet(proxy, path)
+        _depth++
+        try
+          target[k] = v for k, v of obj
+        finally
+          _depth--
+    when 'keys' then (path) ->
+      _depth++
+      try
+        segs = walk(path)
+        obj = proxy
+        for seg in segs
+          return [] unless obj?
+          obj = obj[resolveIndex(seg, obj)]
+        return [] unless obj? and typeof obj is 'object'
+        t = raw(obj)
+        keysSignal(t).value
+        Object.keys(t)
+      finally
+        _depth--
+    when 'has' then (path) ->
+      _depth++
+      try
+        segs = walk(path)
+        return false unless segs.length > 0
+        obj = proxy
+        for seg, i in segs
+          key = resolveIndex(seg, obj)
+          if i is segs.length - 1
+            t = raw(obj)
+            keysSignal(t).value
+            return Object.prototype.hasOwnProperty.call(t, key)
+          return false unless obj?
+          obj = obj[key]
+        false
+      finally
+        _depth--
+    when 'del' then (path) ->
+      _depth++
+      try
+        segs = walk(path)
+        return unless segs.length > 0
+        obj = proxy
+        for seg, i in segs
+          key = resolveIndex(seg, obj)
+          if i is segs.length - 1
+            delete obj[key]
+            return
+          return unless obj?
+          obj = obj[key]
+      finally
+        _depth--
+  cache[prop] = fn
+  fn
 
 export stash = (data = {}) -> makeProxy(data)
 
-export raw = (proxy) -> if proxy?[RAW] then proxy[RAW] else proxy
+export raw = (proxy) -> if proxy?[:raw] then proxy[:raw] else proxy
 
-export isStash = (obj) -> obj?[STASH] is true
+export isStash = (obj) -> obj?[:stash] is true
 
 export persistStash = (app, opts = {}) ->
   target = raw(app) or app
-  return if target[PERSISTED]
-  target[PERSISTED] = true
+  return if target[:persisted]
+  target[:persisted] = true
   storage = if opts.local then localStorage else sessionStorage
   storageKey = opts.key or '__rip_app'
   try
@@ -626,18 +727,77 @@ buildComponentMap = (components, root = 'components') ->
     map[name] = path
   map
 
+# Resolve a .rip import specifier to a path in the component store
+resolveStorePath = (specifier, currentPath, components) ->
+  clean = specifier.replace(/^(\.\.\/|\.\/)+/, '')
+  basename = clean.split('/').pop()
+  # Direct resolution relative to current file in the store
+  if currentPath
+    parts = currentPath.split('/')
+    parts.pop()
+    for seg in specifier.split('/')
+      if seg is '..'
+        parts.pop()
+      else unless seg is '.'
+        parts.push seg
+    candidate = parts.join('/')
+    return candidate if components.exists(candidate)
+  # Try common store prefixes
+  return "components/_lib/#{clean}" if components.exists("components/_lib/#{clean}")
+  return "components/#{clean}" if components.exists("components/#{clean}")
+  # Basename search as last resort
+  for p in components.listAll('components')
+    return p if p.endsWith("/#{basename}")
+  null
+
 compileAndImport = (source, compile, components = null, path = null, resolver = null) ->
   # Check compilation cache
   if components and path
     cached = components.getCompiled(path)
     return cached if cached
 
+  # Mark as in-progress to prevent circular dependency loops
+  if resolver and path
+    resolver.compiling ?= {}
+    resolver.compiling[path] = true
+
   js = compile(source)
 
-  # Resolve component dependencies — scan for PascalCase references in compiled JS
   if resolver
+    importedNames = new Set()
+
+    # Step 1: Rewrite .rip imports to blob URLs
+    if components
+      ripImportRe = /^(\s*import\s+(?:\{([^}]+)\}\s+from\s+|.*?\s+from\s+)?['"])([^'"]*\.rip)(['"];?\s*)$/gm
+      matches = Array.from(js.matchAll(ripImportRe))
+      # Walk matches in reverse so string indices stay valid after each splice
+      for m in matches by -1
+        [full, pre, namedImports, specifier, post] = m
+        storePath = resolveStorePath(specifier, path, components)
+        continue if storePath is path
+        unless storePath
+          msg = "[Rip] Could not resolve import: #{specifier}"
+          msg += " (from #{path})" if path
+          console.warn msg
+          continue
+        # Guard against circular imports — skip if already being compiled
+        unless resolver.blobUrls?[storePath]
+          continue if resolver.compiling?[storePath]
+          depSource = components.read(storePath)
+          if depSource
+            compileAndImport! depSource, compile, components, storePath, resolver
+        blobUrl = resolver.blobUrls?[storePath]
+        if blobUrl
+          replacement = "#{pre}#{blobUrl}#{post}"
+          js = js.slice(0, m.index) + replacement + js.slice(m.index + full.length)
+          if namedImports
+            for n in namedImports.split(',')
+              importedNames.add(n.trim().split(/\s+as\s+/).pop().trim())
+
+    # Step 2: Implicit component resolution — for template-used components not explicitly imported
     needed = {}
     for name, depPath of resolver.map
+      continue if importedNames.has(name)
       if depPath isnt path and js.includes("new #{name}(")
         unless resolver.classes[name]
           depSource = components.read(depPath)
@@ -656,6 +816,13 @@ compileAndImport = (source, compile, components = null, path = null, resolver =
   header = if path then "// #{path}\n" else ''
   blob = new Blob([header + js], { type: 'application/javascript' })
   url = URL.createObjectURL(blob)
+
+  # Cache blob URL so other files can rewrite imports to point here
+  if resolver and path
+    resolver.blobUrls ?= {}
+    resolver.blobUrls[path] = url
+    delete resolver.compiling[path] if resolver.compiling
+
   mod = await import(url)
 
   # Register any components from this module
@@ -680,9 +847,6 @@ export createRenderer = (opts = {}) ->
     container.id = 'app'
     document.body.appendChild container
 
-  # Fade in after first mount (prevents layout-before-content flicker)
-  container.style.opacity = '0'
-
   currentComponent = null
   currentRoute = null
   currentParams = null
@@ -816,15 +980,9 @@ export createRenderer = (opts = {}) ->
         instance.load!(params, query) if instance.load
       oldTarget?.remove()
       router.navigating = false
-      if container.style.opacity is '0'
-        document.fonts.ready.then ->
-          requestAnimationFrame ->
-            container.style.transition = 'opacity 150ms ease-in'
-            container.style.opacity = '1'
 
     catch err
       router.navigating = false
-      container.style.opacity = '1'
       console.error "Renderer: error mounting #{route.file}:", err
       onError({ status: 500, message: err.message, error: err }) if onError