@geastack/core 0.1.23

package/jsx.d.ts

@@ -0,0 +1 @@
+import './index'

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@geastack/core",
+  "version": "0.1.23",
+  "description": "GeaStack app API, reactivity headers, runtime sources, and type declarations.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/geastack/core.git",
+    "directory": "packages/core"
+  },
+  "engines": {
+    "node": ">=20.19"
+  },
+  "type": "module",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./runtime.ts"
+    },
+    "./runtime": {
+      "types": "./index.d.ts",
+      "default": "./runtime.ts"
+    },
+    "./runtime/*": {
+      "default": "./runtime/*.ts"
+    },
+    "./package.json": "./package.json",
+    "./scripts/*": "./scripts/*",
+    "./include/*": "./include/*",
+    "./runtime.cpp": "./runtime.cpp",
+    "./gea_sources.sh": "./gea_sources.sh"
+  },
+  "files": [
+    "app_frame_perf.cpp",
+    "css.d.ts",
+    "events.cpp",
+    "gea_sources.sh",
+    "gea_sources.mjs",
+    "gea_app_entry.cpp",
+    "include",
+    "index.d.ts",
+    "jsx.d.ts",
+    "runtime",
+    "runtime.cpp",
+    "runtime-surface.ts",
+    "runtime.ts",
+    "scripts",
+    "vendor"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "optionalDependencies": {
+    "sharp": "^0.35.0"
+  },
+  "dependencies": {
+    "@babel/generator": "^7.23.0",
+    "@babel/parser": "^7.23.0",
+    "@babel/traverse": "^7.23.0",
+    "@babel/types": "^7.23.0",
+    "@geajs/core": "1.4.0",
+    "@geajs/vite-plugin": "1.4.1",
+    "@geastack/compiler": "^1.0.4",
+    "@geastack/geatsc-plugin-gea": "^0.1.0",
+    "opentype.js": "^2.0.0",
+    "vite": "^8.0.0"
+  }
+}

package/runtime/ble.ts

@@ -0,0 +1,49 @@
+import { Store } from './compiler'
+import { BLE } from './host'
+
+const bleServers: BLEServer[] = []
+let initializedServerCount = 0
+
+export class BLEServer extends Store {
+  deviceName: string
+  appearance: number
+  macAddress: string
+
+  constructor(deviceName: string, appearance: number, macAddress: string) {
+    super()
+    this.deviceName = deviceName
+    this.appearance = appearance
+    this.macAddress = macAddress
+  }
+
+  onConnected(): void {}
+  onDisconnected(): void {}
+  onBound(): void {}
+
+  startAdvertising(): void {
+    BLE.startAdvertising()
+  }
+
+  stopAdvertising(): void {
+    BLE.stopAdvertising()
+  }
+}
+
+// Registration must happen after the complete derived instance exists. Doing
+// this from BLEServer's base constructor snapshots only the base subobject in
+// native builds, losing derived configuration and virtual callbacks.
+export function registerBleServer(server: BLEServer): void {
+  // Embedded builds register the complete derived instance through the
+  // BLEServer class-factory hook. Keep this function as a source-compatible
+  // API without registering the base-class view a second time.
+  void server
+}
+
+export function initBleServers(): void {
+  while (initializedServerCount < bleServers.length) {
+    const server = bleServers[initializedServerCount]
+    initializedServerCount++
+    BLE.init(server.deviceName, server.appearance, server.macAddress)
+    BLE.startAdvertising()
+  }
+}

package/runtime/color.ts

@@ -0,0 +1,21 @@
+// Canvas colour authoring helpers.
+//
+// Apps express colours in the natural 0xRRGGBBAA order (red in the high byte) —
+// the same order you'd write a CSS hex (#RRGGBB) plus an alpha byte. `rgb()` and
+// `rgba()` just pack the channels into that 32-bit number; the actual conversion
+// to this board's native pixel (RGB565 on esp32 — panel-endian-aware — or
+// RGBA8888 on iOS) happens in geatsc's canvas-colour lowering
+// (pixel::nativeFromRrggbbaa). Literal calls fold to a constexpr at build time, so
+// there is no runtime cost; dynamic channels (e.g. a per-face shaded colour) run
+// the same conversion once at the call site. No per-app pixel packing.
+//
+// `>>> 0` keeps the result an unsigned 32-bit value — the alpha byte sets bit 31,
+// which a bitwise OR would otherwise make negative.
+
+export function rgb(r: number, g: number, b: number): number {
+  return (((r & 0xff) << 24) | ((g & 0xff) << 16) | ((b & 0xff) << 8) | 0xff) >>> 0
+}
+
+export function rgba(r: number, g: number, b: number, a: number): number {
+  return (((r & 0xff) << 24) | ((g & 0xff) << 16) | ((b & 0xff) << 8) | (a & 0xff)) >>> 0
+}

package/runtime/compiler.ts

@@ -0,0 +1,43 @@
+import type { GeaElement, GeaJsxElement } from '../index'
+
+/**
+ * `RootElement` is constrained and defaulted exactly as this package's own
+ * `index.d.ts` declares it. The two used to disagree -- the declaration said
+ * `extends GeaElement = GeaElement`, this implementation said `= unknown` --
+ * and since the embedded/geatsc pipeline aliases `@geastack/core` to
+ * `runtime.ts` rather than the declaration file, it was this weaker default
+ * that every compiled app actually saw. `unknown` absorbs the union in
+ * `RootElement | null`, so `el` typed as plain `unknown`: a value the compiler
+ * must box, for no reason other than the two spellings having drifted apart.
+ * `runtime-surface.ts` re-exports these element types from `./index` for the
+ * same reason and says so in the same terms.
+ */
+export class Component<RootElement extends GeaElement = GeaElement, Props = void> {
+  readonly el: RootElement | null = null
+  // Kept in lockstep with `index.d.ts`, which carries the reasoning. This is
+  // the copy that matters for a compiled app -- the pipeline aliases
+  // `@geastack/core` to `runtime.ts`, so this signature, not the declaration
+  // file's, is the one geatsc derives carriers from. `unknown[]`/`unknown` here
+  // meant a boxed argument array and a boxed result on every component.
+  template(_props?: Props): GeaJsxElement | null {
+    return null
+  }
+  // NB: deliberately NO `render` here. `render` is synthesised onto compiled
+  // components by the embedded compiler. Declaring it on the base looks tidier
+  // (it would let mount() drop its cast) but it BREAKS embedded codegen: once
+  // geatsc sees `render` on the statically-typed `Component`, mount()'s
+  // `new component()` constructs the base `Component` by value instead of
+  // dynamically constructing the real runtime class, so the app never mounts.
+  // Verified on esp32-s3-m5stack-papers3. Keep it off the base.
+}
+
+export class Store {}
+
+// EXPERIMENTAL (component-as-store): the vite-plugin rewrites
+// `extends ReactiveComponent` to a lean typed class before codegen (matched by
+// source identifier). This marker only needs to exist so imports resolve during
+// bundling / DOM execution.
+export class ReactiveComponent<
+  RootElement extends GeaElement = GeaElement,
+  Props = void
+> extends Component<RootElement, Props> {}