Merge branch 'gh-pages' of https://github.com/LivelyKernel/lively4-core…

… into gh-pages

README.md

@@ -15,6 +15,7 @@ A project or branch of a project on GitHub can be checked out in multiple direct
 - [lively4-core](https://lively-kernel.org/lively4/lively4-core/start.html)
 - [lively4-stable](https://lively-kernel.org/lively4/lively4-stable/start.html)
 - [lively4-jens](https://lively-kernel.org/lively4/lively4-jens/start.html)
+- [aexpr](https://lively-kernel.org/lively4/aexpr/start.html)
 
 The Lively4 server and GitHub sync tools can check out arbitrary projects, such as the code of [lively4-server](https://lively-kernel.org/lively4/lively4-server/) itself, or the source of a paper hosted by overleaf.
 
@@ -35,4 +36,4 @@ The Lively4 server and GitHub sync tools can check out arbitrary projects, such
 
   - Reactive Programming [RP 2018](https://lively-kernel.org/lively4/lively4-seminars/RP2018/index.md)
 
-### [Imprint](imprint.md)
+### [Imprint](imprint.md)

demos/javascript/sb.js

@@ -0,0 +1,6 @@
+let a = 3
+
+function hello() {
+
+
+}

demos/stefan/untitled-board-game/ubg-card.js

@@ -90,10 +90,23 @@ export default class Card {
     this.ensureUnprintedVersion();
 
     if (notes === undefined) {
-      delete this.versions.last.notes;
+      delete this.notes;
     } else {
       this.notes = notes;
-      this.versions.last.notes = notes;
+    }
+  }
+
+  getRating() {
+    return this.versions.last.rating;
+  }
+
+  setRating(rating) {
+    this.ensureUnprintedVersion();
+
+    if (rating === undefined || rating === 'unset') {
+      delete this.versions.last.rating;
+    } else {
+      this.versions.last.rating = rating;
     }
   }
 

demos/stefan/webxr/README.md

@@ -0,0 +1,28 @@
+<meta charset='utf-8' />
+<meta name='viewport' content='width=device-width, initial-scale=1, user-scalable=no' />
+<meta name='mobile-web-app-capable' content='yes' />
+<meta name='apple-mobile-web-app-capable' content='yes' />
+<link rel='icon' type='image/png' sizes='32x32' href='favicon-32x32.png' />
+<link rel='icon' type='image/png' sizes='96x96' href='favicon-96x96.png' />
+<link rel='stylesheet' href='https://raw.githubusercontent.com/immersive-web/webxr-samples/main/css/common.css' />
+
+# Immersive VR Session
+
+<header>
+  <details open>
+  <summary>Immersive VR Session</summary>
+  <p>
+  This sample demonstrates how to use an 'immersive-vr' XRSession to
+  present a simple WebGL scene to an XR device. The scene is not
+  rendered to the page.
+  <a class="back" href="./">Back</a>
+  </p>
+  </details>
+  </header>
+  <main style='text-align: center;'>
+  <p>Click 'Enter XR' to see content</p> 
+  </main>
+<script type="module">
+  import {} from './webxr.js';
+  initXR(this);
+</script>

demos/stefan/webxr/webxr.js

@@ -0,0 +1,173 @@
+import {WebXRButton} from 'https://raw.githubusercontent.com/immersive-web/webxr-samples/main/js/util/webxr-button.js';
+import {Scene} from 'https://raw.githubusercontent.com/immersive-web/webxr-samples/main/js/render/scenes/scene.js';
+import {Renderer, createWebGLContext} from 'https://raw.githubusercontent.com/immersive-web/webxr-samples/main/js/render/core/renderer.js';
+import {Gltf2Node} from 'https://raw.githubusercontent.com/immersive-web/webxr-samples/main/js/render/nodes/gltf2.js';
+import {SkyboxNode} from 'https://raw.githubusercontent.com/immersive-web/webxr-samples/main/js/render/nodes/skybox.js';
+import {QueryArgs} from 'https://raw.githubusercontent.com/immersive-web/webxr-samples/main/js/util/query-args.js';
+
+// If requested, use the polyfill to provide support for mobile devices
+// and devices which only support WebVR.
+import WebXRPolyfill from 'https://raw.githubusercontent.com/immersive-web/webxr-samples/main/js/third-party/webxr-polyfill/build/webxr-polyfill.module.js';
+if (QueryArgs.getBool('usePolyfill', true)) {
+  let polyfill = new WebXRPolyfill();
+}
+
+// XR globals.
+let xrButton = null;
+let xrRefSpace = null;
+
+// WebGL scene globals.
+let gl = null;
+let renderer = null;
+let scene = new Scene();
+scene.addNode(new Gltf2Node({url: 'https://raw.githubusercontent.com/immersive-web/webxr-samples/main/media/gltf/space/space.gltf'}));
+scene.addNode(new SkyboxNode({url: 'https://raw.githubusercontent.com/immersive-web/webxr-samples/main/media/textures/milky-way-4k.png'}));
+
+// Checks to see if WebXR is available and, if so, queries a list of
+// XRDevices that are connected to the system.
+export default function initXR(context) {
+  // Adds a helper button to the page that indicates if any XRDevices are
+  // available and let's the user pick between them if there's multiple.
+  xrButton = new WebXRButton({
+    onRequestSession: onRequestSession,
+    onEndSession: onEndSession
+  });
+  lively.query(context, 'header').appendChild(xrButton.domElement);
+
+  // Is WebXR available on this UA?
+  if (navigator.xr) {
+    // If the device allows creation of exclusive sessions set it as the
+    // target of the 'Enter XR' button.
+    navigator.xr.isSessionSupported('immersive-vr').then((supported) => {
+      xrButton.enabled = supported;
+    });
+  }
+}
+
+// Called when the user selects a device to present to. In response we
+// will request an exclusive session from that device.
+function onRequestSession() {
+  return navigator.xr.requestSession('immersive-vr').then(onSessionStarted);
+}
+
+// Called when we've successfully acquired a XRSession. In response we
+// will set up the necessary session state and kick off the frame loop.
+function onSessionStarted(session) {
+  // This informs the 'Enter XR' button that the session has started and
+  // that it should display 'Exit XR' instead.
+  xrButton.setSession(session);
+
+  // Listen for the sessions 'end' event so we can respond if the user
+  // or UA ends the session for any reason.
+  session.addEventListener('end', onSessionEnded);
+
+  // Create a WebGL context to render with, initialized to be compatible
+  // with the XRDisplay we're presenting to.
+  gl = createWebGLContext({
+    xrCompatible: true
+  });
+
+  // Create a renderer with that GL context (this is just for the samples
+  // framework and has nothing to do with WebXR specifically.)
+  renderer = new Renderer(gl);
+
+  // Set the scene's renderer, which creates the necessary GPU resources.
+  scene.setRenderer(renderer);
+
+  // Use the new WebGL context to create a XRWebGLLayer and set it as the
+  // sessions baseLayer. This allows any content rendered to the layer to
+  // be displayed on the XRDevice.
+  session.updateRenderState({ baseLayer: new XRWebGLLayer(session, gl) });
+
+  // Get a frame of reference, which is required for querying poses. In
+  // this case an 'local' frame of reference means that all poses will
+  // be relative to the location where the XRDevice was first detected.
+  session.requestReferenceSpace('local').then((refSpace) => {
+    xrRefSpace = refSpace;
+
+    // Inform the session that we're ready to begin drawing.
+    session.requestAnimationFrame(onXRFrame);
+  });
+}
+
+// Called when the user clicks the 'Exit XR' button. In response we end
+// the session.
+function onEndSession(session) {
+  session.end();
+}
+
+// Called either when the user has explicitly ended the session (like in
+// onEndSession()) or when the UA has ended the session for any reason.
+// At this point the session object is no longer usable and should be
+// discarded.
+function onSessionEnded(event) {
+  xrButton.setSession(null);
+
+  // In this simple case discard the WebGL context too, since we're not
+  // rendering anything else to the screen with it.
+  renderer = null;
+}
+
+// Called every time the XRSession requests that a new frame be drawn.
+function onXRFrame(t, frame) {
+  let session = frame.session;
+
+  // Per-frame scene setup. Nothing WebXR specific here.
+  scene.startFrame();
+
+  // Inform the session that we're ready for the next frame.
+  session.requestAnimationFrame(onXRFrame);
+
+  // Get the XRDevice pose relative to the Frame of Reference we created
+  // earlier.
+  let pose = frame.getViewerPose(xrRefSpace);
+
+  // Getting the pose may fail if, for example, tracking is lost. So we
+  // have to check to make sure that we got a valid pose before attempting
+  // to render with it. If not in this case we'll just leave the
+  // framebuffer cleared, so tracking loss means the scene will simply
+  // disappear.
+  if (pose) {
+    let glLayer = session.renderState.baseLayer;
+
+    // If we do have a valid pose, bind the WebGL layer's framebuffer,
+    // which is where any content to be displayed on the XRDevice must be
+    // rendered.
+    gl.bindFramebuffer(gl.FRAMEBUFFER, glLayer.framebuffer);
+
+    // Clear the framebuffer
+    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
+
+    // Loop through each of the views reported by the frame and draw them
+    // into the corresponding viewport.
+    for (let view of pose.views) {
+      let viewport = glLayer.getViewport(view);
+      gl.viewport(viewport.x, viewport.y,
+                  viewport.width, viewport.height);
+
+      // Draw this view of the scene. What happens in this function really
+      // isn't all that important. What is important is that it renders
+      // into the XRWebGLLayer's framebuffer, using the viewport into that
+      // framebuffer reported by the current view, and using the
+      // projection matrix and view transform from the current view.
+      // We bound the framebuffer and viewport up above, and are passing
+      // in the appropriate matrices here to be used when rendering.
+      scene.draw(view.projectionMatrix, view.transform);
+    }
+  } else {
+    // There's several options for handling cases where no pose is given.
+    // The simplest, which these samples opt for, is to simply not draw
+    // anything. That way the device will continue to show the last frame
+    // drawn, possibly even with reprojection. Alternately you could
+    // re-draw the scene again with the last known good pose (which is now
+    // likely to be wrong), clear to black, or draw a head-locked message
+    // for the user indicating that they should try to get back to an area
+    // with better tracking. In all cases it's possible that the device
+    // may override what is drawn here to show the user it's own error
+    // message, so it should not be anything critical to the application's
+    // use.
+  }
+
+  // Per-frame scene teardown. Nothing WebXR specific here.
+  scene.endFrame();
+}

demos/tree-sitter/codemirror.md

@@ -0,0 +1,75 @@
+# Code Mirror Shards Sandblocks Proof of Concept
+
+## Issues:
+
+- [ ] (cursor in/out)
+- [ ] keep focus while typing
+- [X] hide line numbers
+- [X] hide scrollbars
+- [ ] update RegExp match while editing
+- [ ] Stefan's hide indentation/whitespace issue in shards
+
+## Probe Example
+
+<script>
+
+customElements.define(
+    "probe-widget",
+    class extends HTMLElement {
+      constructor() {
+        super();
+        this.attachShadow({ mode: "open" });
+        this.addEventListener("keyup", evt => {
+          // evt.preventDefault()
+          // evt.stopPropagation()
+        })
+
+        this.addEventListener("keydown", evt => {
+          // evt.preventDefault()
+          // evt.stopPropagation()
+        })
+        this.shadowRoot.innerHTML = `
+          <div style="border: 1px solid gray">PROBE 
+          <lively-code-mirror class="shard"></lively-code-mirror>
+          <slot></slot></div>
+        `;
+      }
+  })
+
+
+  var outerLivelyCodeMirror = await (<lively-code-mirror></lively-code-mirror>)
+  outerLivelyCodeMirror.value = `var a = probe(3 + 4)`
+
+
+  var debugLivelyCodeMirror = await (<lively-code-mirror></lively-code-mirror>)
+  debugLivelyCodeMirror.editor.swapDoc(outerLivelyCodeMirror.editor.linkedDoc())
+
+  var regEx = new RegExp(/((probe\()(.*))\)/, "g");
+  do {
+    var m = regEx.exec(outerLivelyCodeMirror.value);
+    if (m) {
+      var from = m.index
+      var to = m.index + m[0].length 
+
+
+      var innerFrom = m.index + m[2].length 
+      var innerTo = m.index + m[1].length       
+      var editor = outerLivelyCodeMirror.editor
+
+      var comp = await outerLivelyCodeMirror.wrapWidget("probe-widget", 
+          editor.posFromIndex(from), 
+          editor.posFromIndex(to))
+
+      var innerLivelyCodeMirror = comp.shadowRoot.querySelector("lively-code-mirror")
+          innerLivelyCodeMirror.editor.swapDoc(editor.linkedDoc())
+      const opts = {collapsed: true, clearWhenEmpty: false, inclusiveLeft: false, inclusiveRight: true};
+      innerLivelyCodeMirror.editor.getDoc().markText(editor.posFromIndex(-1), editor.posFromIndex(innerFrom), opts);
+      innerLivelyCodeMirror.editor.getDoc().markText(editor.posFromIndex(innerTo), editor.posFromIndex(innerLivelyCodeMirror.value.length), opts);
+
+
+      debugger
+    }
+  } while (m);
+
+  (<div>{outerLivelyCodeMirror}DEBUG:{debugLivelyCodeMirror}</div>)
+</script>

doc/journal/2023-12-14.md/index.md

@@ -0,0 +1,8 @@
+## 2023-12-14 Tom's Window Wishlist for Christmas
+*Author: @JensLincke*
+
+
+- [ ] alt+drag on window moves it
+- [ ] open window attached to cursor (centered around cursor)
+  - [ ] attached window can be resize via press down and drag
+    - [ ] scale in directions

src/client/debug.js

@@ -0,0 +1,53 @@
+import {Logging} from "src/client/morphic/component-loader.js"
+
+var debugCounterByClass = new Map()
+var debugPrintMap = new WeakMap() // obj -> string
+var debugPrintReverseMap = new Map() // string -> obj
+
+// for debugging WeakRefs....
+// var debugReg = new FinalizationRegistry(value => console.warn('COLLECTED: ' + value))
+
+/*globals WeakRef */
+
+export {Logging}
+
+function debugPrint(element) {
+  var print = debugPrintMap.get(element)
+  if (!print) {
+    var className = element.constructor.name
+    var counter = debugCounterByClass.get(className) || 0
+    counter++
+    debugCounterByClass.set(className, counter)
+    print = className + counter
+    debugPrintMap.set(element, print)
+    debugSet(print, element)
+  }
+  return print
+}
+
+export function debugGet(name) {
+  let ref = debugPrintReverseMap.get(name)
+  return ref && ref.deref()
+}
+
+// debugGet("sb-block61")
+
+
+// let obj = document.body
+
+export function debugSet(name, obj) {
+  let ref = new WeakRef(obj)
+  // debugReg.register(obj, name)
+  return debugPrintReverseMap.set(name, ref)
+}
+
+Logging.enable()
+
+Logging.setLog((element, ...args) => {
+
+  if (element  && element instanceof HTMLElement ) {
+    console.log(debugPrint(element), ...args)
+  }
+})
+
+