jsmdcui 0.3.0

package/src/config/colorscheme.js

@@ -0,0 +1,99 @@
+export const DEFAULT_STYLE = {
+  fg: "default",
+  bg: "default",
+  bold: false,
+  italic: false,
+  reverse: false,
+  underline: false,
+};
+
+const COLOR_LINK = /color-link\s+(\S*)\s+"(.*)"/;
+const INCLUDE = /include\s+"(.*)"/;
+
+export class Colorscheme {
+  constructor(runtime) {
+    this.runtime = runtime;
+    this.styles = new Map();
+    this.defaultStyle = { ...DEFAULT_STYLE };
+  }
+
+  async load(name = "default", parsed = new Set()) {
+    const file = this.runtime.find(0, name);
+    if (!file) throw new Error(`${name} is not a valid colorscheme`);
+    parsed.add(name);
+    const parsedStyles = await this.parse(name, await file.text(), parsed);
+    this.styles = parsedStyles;
+    return this;
+  }
+
+  async parse(name, text, parsed = new Set()) {
+    const styles = new Map();
+    for (const rawLine of String(text).split("\n")) {
+      const line = rawLine.trim();
+      if (!line || line.startsWith("#")) continue;
+
+      const include = line.match(INCLUDE);
+      if (include) {
+        const includeName = include[1];
+        if (!parsed.has(includeName)) {
+          const file = this.runtime.find(0, includeName);
+          if (!file) throw new Error(`${includeName} is not a valid colorscheme`);
+          parsed.add(includeName);
+          const includedStyles = await this.parse(includeName, await file.text(), parsed);
+          for (const [key, value] of includedStyles) styles.set(key, value);
+        }
+        continue;
+      }
+
+      const match = line.match(COLOR_LINK);
+      if (!match) throw new Error(`Color-link statement is not valid: ${rawLine}`);
+      const style = stringToStyle(match[2], this.defaultStyle);
+      styles.set(match[1], style);
+      if (match[1] === "default") this.defaultStyle = style;
+    }
+    if (styles.has("default")) this.defaultStyle = styles.get("default");
+    return styles;
+  }
+
+  get(group) {
+    if (!group) return this.defaultStyle;
+    const parts = String(group).split(".");
+    let style = this.styles.get(group);
+    if (parts.length > 1) {
+      let cur = "";
+      for (const part of parts) {
+        cur = cur ? `${cur}.${part}` : part;
+        if (this.styles.has(cur)) style = this.styles.get(cur);
+      }
+    }
+    return style ?? stringToStyle(group, this.defaultStyle);
+  }
+}
+
+export function stringToStyle(input, base = DEFAULT_STYLE) {
+  const text = String(input);
+  const colorPart = text.split(/\s+/).at(-1) ?? "";
+  const [fgRaw = "default", bgRaw = "default"] = colorPart.split(",");
+  return {
+    fg: stringToColor(fgRaw.trim(), base.fg),
+    bg: stringToColor(bgRaw.trim(), base.bg),
+    bold: base.bold || text.includes("bold"),
+    italic: base.italic || text.includes("italic"),
+    reverse: base.reverse || text.includes("reverse"),
+    underline: base.underline || text.includes("underline"),
+  };
+}
+
+export function stringToColor(value, fallback = "default") {
+  const color = String(value || "default").trim();
+  if (color === "default" || color === "") return fallback;
+  if (/^\d+$/.test(color)) return Number(color);
+  if (/^#[0-9a-fA-F]{6}$/.test(color)) return color;
+  const names = new Set([
+    "black", "red", "green", "yellow", "blue", "magenta", "cyan", "white",
+    "brightblack", "brightred", "brightgreen", "brightyellow", "brightblue",
+    "brightmagenta", "brightcyan", "brightwhite", "lightblack", "lightred",
+    "lightgreen", "lightyellow", "lightblue", "lightmagenta", "lightcyan", "lightwhite",
+  ]);
+  return names.has(color) ? color : fallback;
+}

package/src/config/config.js

@@ -0,0 +1,122 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+//import { Glob } from "bun";
+import { defaultAllSettings, OPTION_CHOICES, LOCAL_SETTINGS } from "./defaults.js";
+import { isHex3Encoding, isMdcuiEncoding } from "../runtime/encodings.js";
+
+export class Config {
+  constructor({ configDir = "" } = {}) {
+    this.configDir = configDir || defaultConfigDir();
+    this.globalSettings = defaultAllSettings();
+    this.volatileSettings = new Set();
+    this.modifiedSettings = new Set();
+    this.parsedSettings = {};
+  }
+
+  async init() {
+    await mkdir(this.configDir, { recursive: true });
+    await this.readSettings();
+    return this;
+  }
+
+  async readSettings() {
+    const path = join(this.configDir, "settings.json");
+    if (!existsSync(path)) return;
+    const text = await readFile(path, "utf8");
+    if (text.trimStart().startsWith("null") || text.trim() === "") return;
+    this.parsedSettings = Bun.JSON5.parse(text);
+    this.applyParsedSettings(this.parsedSettings);
+  }
+
+  applyCliSettings(settings) {
+    for (const [key, raw] of settings) {
+      if (!(key in this.globalSettings)) continue;
+      this.setGlobalOptionNative(key, parseSetting(raw), { volatile: true });
+    }
+  }
+
+  applyParsedSettings(parsed) {
+    for (const [key, value] of Object.entries(parsed)) {
+      if (key.startsWith("ft:")) continue;
+      if (key.startsWith("glob:")) {
+        //new Glob(key.slice(5));
+        continue;
+      }
+      if (!(key in this.globalSettings)) continue;
+      this.setGlobalOptionNative(key, normalizeSetting(key, value), { modified: false });
+    }
+  }
+
+  registerCommonOption(plugin, option, value) {
+    this.registerGlobalOption(`${plugin}.${option}`, value);
+  }
+
+  registerGlobalOption(option, value) {
+    if (!(option in this.globalSettings)) this.globalSettings[option] = value;
+    if (Object.hasOwn(this.parsedSettings, option)) {
+      this.setGlobalOptionNative(option, normalizeSetting(option, this.parsedSettings[option]), { modified: false });
+    }
+  }
+
+  getGlobalOption(option) {
+    return this.globalSettings[option];
+  }
+
+  setGlobalOptionNative(option, value, { volatile = false, modified = true } = {}) {
+    if (!(option in this.globalSettings)) throw new Error(`Invalid option: ${option}`);
+    validateOption(option, value);
+    this.globalSettings[option] = value;
+    if (volatile) this.volatileSettings.add(option);
+    if (modified) this.modifiedSettings.add(option);
+  }
+
+  async saveSettings() {
+    const path = join(this.configDir, "settings.json");
+    const out = { ...this.parsedSettings };
+    for (const key of this.modifiedSettings) {
+      if (!this.volatileSettings.has(key) && !LOCAL_SETTINGS.has(key)) out[key] = this.globalSettings[key];
+    }
+    // Remove any local-only settings that may have leaked into parsedSettings previously.
+    for (const key of LOCAL_SETTINGS) delete out[key];
+    await Bun.write(path, JSON.stringify(out, null, "    ") + "\n");
+    this.parsedSettings = { ...out };
+  }
+}
+
+export function defaultConfigDir() {
+  if (process.env.MICRO_CONFIG_HOME) return process.env.MICRO_CONFIG_HOME;
+  const xdg = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+  return join(xdg, "micro");
+}
+
+export function parseSetting(value) {
+  if (value === "true" || value === "on") return true;
+  if (value === "false" || value === "off") return false;
+  if (/^-?\d+(\.\d+)?$/.test(value)) return Number(value);
+  return value;
+}
+
+function normalizeSetting(key, value) {
+  if (key === "autosave" && typeof value === "boolean") return value ? 8 : 0;
+  return value;
+}
+
+function validateOption(option, value) {
+  if (option === "encoding") {
+    const encoding = String(value || "utf-8");
+    if (isMdcuiEncoding(encoding)) return;
+    if (isHex3Encoding(encoding)) return;
+    try { new TextDecoder(encoding); }
+    catch { throw new Error(`Invalid encoding: ${value}`); }
+  }
+  const choices = OPTION_CHOICES[option];
+  if (choices && !choices.includes(value)) {
+    throw new Error(`Invalid value for ${option}: ${value}`);
+  }
+  if (["autosave", "colorcolumn", "detectlimit", "pageoverlap", "scrollmargin", "scrollspeed"].includes(option) && Number(value) < 0) {
+    throw new Error(`${option} must be non-negative`);
+  }
+  if (option === "tabsize" && Number(value) <= 0) throw new Error("tabsize must be positive");
+}

package/src/config/defaults.js

@@ -0,0 +1,109 @@
+export const DEFAULT_COMMON_SETTINGS = {
+  autoindent: true,
+  autosu: false,
+  backup: true,
+  backupdir: "",
+  basename: false,
+  colorcolumn: 0,
+  cursorline: true,
+  detectlimit: 100,
+  diffgutter: false,
+  encoding: "utf-8",
+  eofnewline: true,
+  fastdirty: false,
+  fileformat: defaultFileFormat(),
+  filetype: "unknown",
+  hlsearch: false,
+  hltaberrors: false,
+  hltrailingws: false,
+  ignorecase: true,
+  incsearch: true,
+  indentchar: " ",
+  keepautoindent: false,
+  matchbrace: true,
+  matchbraceleft: true,
+  matchbracestyle: "underline",
+  mkparents: false,
+  pageoverlap: 2,
+  permbackup: false,
+  readonly: false,
+  relativeruler: false,
+  reload: "prompt",
+  rmtrailingws: false,
+  ruler: true,
+  savecursor: false,
+  saveundo: false,
+  scrollbar: false,
+  scrollmargin: 3,
+  scrollspeed: 2,
+  showchars: "",
+  smartpaste: true,
+  softwrap: false,
+  splitbottom: true,
+  splitright: true,
+  statusformatl: "$(filename) $(modified)$(overwrite)($(line),$(col)) $(status.paste)| ft:$(opt:filetype) | $(opt:fileformat) | $(opt:encoding)",
+  statusformatr: "$(bind:ToggleKeyMenu): bindings, $(bind:ToggleHelp): help",
+  statusline: true,
+  syntax: true,
+  tabmovement: false,
+  tabsize: 4,
+  tabstospaces: false,
+  truecolor: "auto",
+  useprimary: true,
+  wordwrap: false,
+};
+
+export const DEFAULT_GLOBAL_ONLY_SETTINGS = {
+  autosave: 0,
+  clipboard: "external",
+  colorscheme: "default",
+  cursorshape: "block",
+  savehistory: true,
+  divchars: "|-",
+  divreverse: true,
+  fakecursor: process.platform === "win32",
+  helpsplit: "hsplit",
+  infobar: true,
+  keymenu: false,
+  lockbindings: false,
+  mouse: true,
+  multiopen: "tab",
+  parsecursor: false,
+  paste: false,
+  pluginchannels: ["https://raw.githubusercontent.com/micro-editor/plugin-channel/master/channel.json"],
+  pluginrepos: [],
+  savehistory: true,
+  scrollbarchar: "|",
+  sucmd: "sudo",
+  tabhighlight: false,
+  tabreverse: true,
+  xterm: false,
+};
+
+export const OPTION_CHOICES = {
+  clipboard: ["internal", "external", "terminal"],
+  cursorshape: [
+    "default",
+    "block", "blinking-block",
+    "underline", "blinking-underline",
+    "bar", "blinking-bar",
+  ],
+  fileformat: ["unix", "dos"],
+  helpsplit: ["hsplit", "vsplit"],
+  matchbracestyle: ["underline", "highlight"],
+  multiopen: ["tab", "hsplit", "vsplit"],
+  reload: ["prompt", "auto", "disabled"],
+  truecolor: ["auto", "on", "off"],
+};
+
+// Settings that are buffer-local only and must never be written to the global config file.
+// Mirrors Go micro's config.LocalSettings.
+export const LOCAL_SETTINGS = new Set(["readonly", "filetype", "fileformat"]);
+
+export function defaultAllSettings() {
+  return { ...DEFAULT_COMMON_SETTINGS, ...DEFAULT_GLOBAL_ONLY_SETTINGS };
+}
+
+function defaultFileFormat() {
+  return process.platform === "win32" ? "dos" : "unix";
+}

package/src/cui/rpc.mjs

@@ -0,0 +1,259 @@
+
+
+
+
+
+const crlf="\r\n"
+
+let apilist = new Map()
+
+export const jss = JSON.stringify
+
+
+export async function evalBack(backmod, qjson)
+{
+
+try{
+
+
+
+/* Contract of requestJson(qjson)
+type RpcPacket = [
+  func: string,
+  argv: unknown[],
+  envp?: Record<string, unknown>,
+];
+*/
+
+//  DiscoverApi ApiCaller
+
+
+let [ func, argv, envp ] = qjson
+
+func = (func || '')+'' ;
+
+if(process.env.RPC_DEBUG)
+  console.log(func);
+
+if(!apilist.get(backmod))
+  apilist.set(backmod,DiscoverApi(backmod));
+
+const apilistMod = apilist.get(backmod)
+
+if(func=="_discover")
+{
+  return apilistMod ;
+}
+else if(apilistMod[func])
+{
+  if(Array.isArray(argv))
+   return await backmod[func]?.apply?.(envp,argv);
+  else
+   return await ApiCaller(backmod,func,argv,envp);
+}
+else
+{
+  return "Unknown func 未知函式: "+func+
+         crlf+JSON.stringify(argv);
+}
+
+
+
+}catch(e)
+{
+  console.log(e);
+  return (e.stack);
+}
+
+}  //  end of evalBack
+
+
+const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
+
+function safeFrontError(e)
+{
+  return {
+    ok: false,
+    error: e?.stack || String(e),
+  };
+}
+
+function safeFrontValue(value)
+{
+  if (typeof value !== "function") return value;
+  return function(...args) {
+    try {
+      const result = value.apply(this, args);
+      if (result && typeof result.then === "function")
+        return result.catch(safeFrontError);
+      return result;
+    } catch(e) {
+      return safeFrontError(e);
+    }
+  };
+}
+
+export async function evalFront(mod, text) 
+{
+try{
+
+    text = text.replace(/^javascript:/, "");
+
+    const names = Object.keys(mod);
+    const values = Object.values(mod).map(safeFrontValue);
+
+    try {
+      return await new AsyncFunction(...names, `return await (${text})`)(...values);
+    } catch(e) {
+      if (e instanceof SyntaxError)
+        return await new AsyncFunction(...names, text)(...values);
+      throw e;
+    }
+
+}catch(e)
+{
+  return safeFrontError(e);
+}
+    
+}
+
+
+export const rpcraw = async (func,argv,envp)=>{
+    
+  const apilistMod = await FrontendDiscoverApi()
+  
+  if(apilistMod[func])
+    return await fetch("rpc", {
+      method: "POST",
+      body: JSON.stringify([
+        func,argv,envp
+      ])
+    }).then(r=>r.json()).catch(e=>e) ;
+  else if(func=="_discover")
+  {
+    if(argv[0])
+      return jss(apilistMod,null,1) ;
+    else
+      return apilistMod ;
+  }
+  else
+    return "Unknown func 未知函式: "+func+
+           crlf+JSON.stringify(argv);
+}
+
+export const rpcproxy = new Proxy(rpcraw,{
+  get(target, prop, receiver) {
+    if (prop in target) {
+      return Reflect.get(target, prop, receiver);
+    }
+
+    if (typeof prop !== "string") {
+      return undefined;
+    }
+
+    target[prop] = async function(...argv) {
+      await FrontendDiscoverApi()
+      return await target(prop, argv, this);
+    };
+
+    return target[prop];
+  },
+  ownKeys() {
+    return Object.keys(apilist.get(0)||{});
+  },
+  getOwnPropertyDescriptor(target, prop) {
+    const apilistMod = apilist.get(0)||{};
+
+    if(prop in apilistMod) {
+      return {
+        enumerable: true,
+        configurable: true,
+      };
+    }
+
+    return Reflect.getOwnPropertyDescriptor(target, prop);
+  }
+});
+
+export var rpc = rpcproxy
+
+
+
+// functions cannot contain ( ) , 
+export function getfuncparams( func )
+{
+	if( typeof(func) != "function" )
+	  return [];
+	
+	let rs = func.toString();
+	let m = rs.match( /\(([\s\S]*?)\)/ );
+	if( !m ) return [];
+	rs = m[1] ;
+	
+	return rs.split(",").map(i=>i.trim()) ;
+}
+
+
+export async function FrontendDiscoverApi()
+{
+  if(!apilist.get(0))
+    apilist.set(0, await fetch("rpc", {
+      method: "POST",
+      body: JSON.stringify(["_discover"])
+    }).then(r=>r.json()).catch(e=>e) ) ;
+    
+  return apilist.get(0);
+}
+
+
+// filters out _ starting functions
+export function DiscoverApi( obj ) // module_obj
+{
+	let karr = Object.keys( obj );
+	karr = karr
+	  .filter( i=>( !i.startsWith('_') && 
+	                typeof(obj[i]) == "function" ) )
+	  .map(i=>{
+          const fname = obj[i].name || obj[i].Name ;
+          
+          if( fname && fname != i )
+            return [ i, [[ fname ]] ];
+            
+          return [ i, getfuncparams(obj[i]) ];
+      });
+	
+	return Object.fromEntries( karr ) ;
+}
+
+
+
+/*
+ * Module object from import * as modobj from 'mod.mjs'
+ * Parameters object
+ */
+export async function ApiCaller( modobj, cmd, pobj,envp )
+{
+  const func = modobj[cmd] ;
+
+  if(!pobj) pobj = {} ;
+
+  if( func && typeof(func) == "function" )
+  {
+    if(!func.args)
+    {
+      func.args = getfuncparams( func ) ;
+      func.args = func.args.map(i=>{
+        let ret = i.split("=")[0]
+        ret=(ret||"")+""
+        return ret.trim();
+      });
+    }
+    
+    let parr = func.args.map(i=>pobj[i]) ;
+
+    return await func.apply(envp,parr) ;
+  }
+  else
+    return "Failed: No such function as" +
+           crlf + cmd ;
+}

package/src/cui/server.mjs

@@ -0,0 +1,116 @@
+#!/usr/bin/env bun
+
+import { evalBack } from "./rpc.mjs";
+
+const csl = console.log
+const mda = Bun.markdown.ansi
+
+
+import homepage from "./testapp.md.html"
+import * as backmod from "./testapp.md.back.js";
+
+
+/*
+// Wait until Bun fixes dynamic html import bundle
+
+process.env.PUBLIC_MDPATH ||= "testapp.md"
+
+const { default: homepage } = 
+    await import(
+      "./" + 
+      process.env.PUBLIC_MDPATH + 
+      ".html"
+    ) ;
+
+const backmod = 
+    await import(
+      './' +
+      process.env.PUBLIC_MDPATH + 
+      ".back.js"
+    ) ;
+    
+*/
+
+
+function json(data, init = {}) {
+  return Response.json(data, {
+    headers: {
+      "access-control-allow-origin": "*",
+      ...init.headers,
+    },
+    ...init,
+  });
+}
+
+
+export function main()
+{
+
+
+
+const basePath = "/" + crypto.randomUUID()
+const pathname = basePath + "/"
+const server = Bun.serve({
+  port: Number(process.env.PORT || 3000),
+  development: {
+    hmr: true,
+    console: true,
+  },
+  routes: {
+    [basePath]: (req) => Response.redirect(new URL(pathname, req.url), 308),
+    [pathname]: homepage,
+
+    [pathname + "rpc"]: async (req) => {
+      csl("\n"+mda("## "+req.method+" "+req.url))
+    
+      if (req.method === "OPTIONS") {
+        return new Response(null, {
+          headers: {
+            "access-control-allow-origin": "*",
+            "access-control-allow-methods": "POST,OPTIONS",
+            "access-control-allow-headers": "content-type",
+          },
+        });
+      }
+
+      if (req.method !== "POST") {
+        csl('illegal method')
+        return new Response("Method Not Allowed", { status: 405 });
+      }
+
+      try {
+        const packet = await req.json();
+        
+        csl('req json:',packet)
+        
+        const result = await evalBack(backmod, packet);
+
+        return json(result ?? null);
+      } catch (error) {
+        return json(
+          {
+            ok: false,
+            error: error?.stack || String(error),
+          },
+          { status: 400 },
+        );
+      }
+    },
+  },
+
+  fetch() {
+    return new Response("Not Found", { status: 404 });
+  },
+});
+
+console.log(mda("- Bun RPC server listening on"));
+console.log(`http://localhost:${server.port}${pathname}`);
+
+
+
+return server
+
+} // main
+
+if(import.meta.main)
+  main()