@limno/core 0.1.0

package/dist/loader.cjs

@@ -0,0 +1,133 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/loader.ts
+var loader_exports = {};
+__export(loader_exports, {
+  default: () => limnoLoader
+});
+module.exports = __toCommonJS(loader_exports);
+var import_node_path = __toESM(require("path"), 1);
+
+// src/files.ts
+var SOURCE_FILES = /\.(jsx|tsx|js|mjs)$/;
+function shouldStamp(file, include = SOURCE_FILES) {
+  return include.test(file) && !/[\\/]node_modules[\\/]/.test(file) && !file.startsWith("\0");
+}
+
+// src/transform.ts
+var import_parser = require("@babel/parser");
+var import_traverse = __toESM(require("@babel/traverse"), 1);
+var import_magic_string = __toESM(require("magic-string"), 1);
+var traverse = import_traverse.default.default ?? import_traverse.default;
+var SKIP_COMPOSITES = /* @__PURE__ */ new Set(["Fragment", "React.Fragment", "Suspense", "React.Suspense", "StrictMode", "React.StrictMode", "Profiler", "React.Profiler", "Activity"]);
+function jsxName(name) {
+  if (name.type === "JSXIdentifier") return name.name;
+  if (name.type === "JSXNamespacedName") return `${name.namespace.name}:${name.name.name}`;
+  return `${jsxName(name.object)}.${name.property.name}`;
+}
+var isCapitalized = (s) => /^[A-Z]/.test(s);
+function componentName(path2, fileBase) {
+  let p = path2.getFunctionParent();
+  while (p) {
+    const node = p.node;
+    let name;
+    if ((node.type === "FunctionDeclaration" || node.type === "FunctionExpression") && node.id) name = node.id.name;
+    if (!name) {
+      let parent = p.parentPath;
+      while (parent && parent.node.type === "CallExpression") parent = parent.parentPath;
+      if (parent?.node.type === "VariableDeclarator" && parent.node.id.type === "Identifier") name = parent.node.id.name;
+      else if (parent?.node.type === "ExportDefaultDeclaration") name = fileBase;
+      else if (parent?.node.type === "ClassMethod" || parent?.node.type === "ObjectMethod") name = void 0;
+    }
+    if (!name && p.node.type === "ClassMethod") {
+      const cls = p.findParent((q) => q.isClassDeclaration());
+      name = cls?.node.id?.name;
+    }
+    if (name && isCapitalized(name)) return name;
+    p = p.parentPath ? p.parentPath.getFunctionParent() : null;
+  }
+  return void 0;
+}
+function hasAttr(node, name) {
+  return node.attributes.some((a) => a.type === "JSXAttribute" && a.name.type === "JSXIdentifier" && a.name.name === name);
+}
+var escapeAttr = (s) => s.replace(/&/g, "&").replace(/"/g, """);
+function stampSource(code, id, relFile) {
+  if (!code.includes("<")) return null;
+  const isTs = /\.tsx$/.test(id);
+  let ast;
+  try {
+    ast = (0, import_parser.parse)(code, {
+      sourceType: "module",
+      plugins: isTs ? ["jsx", "typescript"] : ["jsx"],
+      errorRecovery: true
+    });
+  } catch {
+    return null;
+  }
+  const s = new import_magic_string.default(code);
+  const fileBase = relFile.split("/").pop().replace(/\.[jt]sx?$/, "").replace(/^./, (c) => c.toUpperCase());
+  let touched = false;
+  traverse(ast, {
+    JSXOpeningElement(path2) {
+      const node = path2.node;
+      const loc = node.loc;
+      if (!loc || node.name.end == null) return;
+      const name = jsxName(node.name);
+      const where = `${relFile}:${loc.start.line}:${loc.start.column + 1}`;
+      const host = node.name.type === "JSXIdentifier" && !isCapitalized(name);
+      if (host) {
+        if (hasAttr(node, "data-limno-src")) return;
+        const comp = componentName(path2, fileBase);
+        s.appendLeft(node.name.end, ` data-limno-src="${escapeAttr(where)}"${comp ? ` data-limno-comp="${escapeAttr(comp)}"` : ""}`);
+        touched = true;
+      } else {
+        if (SKIP_COMPOSITES.has(name) || /\.(Provider|Consumer)$/.test(name) || hasAttr(node, "data-limno-callsite")) return;
+        s.appendLeft(node.name.end, ` data-limno-callsite="${escapeAttr(where)}"`);
+        touched = true;
+      }
+    }
+  });
+  if (!touched) return null;
+  return { code: s.toString(), map: s.generateMap({ hires: "boundary", source: id, includeContent: true }) };
+}
+
+// src/loader.ts
+function limnoLoader(source, inputMap) {
+  this.cacheable?.(true);
+  const opts = this.getOptions?.() ?? (typeof this.query === "object" ? this.query : {}) ?? {};
+  const root = opts.root ?? process.cwd();
+  const file = this.resourcePath;
+  if (!shouldStamp(file)) return this.callback(null, source, inputMap);
+  const rel = import_node_path.default.relative(root, file).split(import_node_path.default.sep).join("/");
+  const out = stampSource(source, file, rel);
+  if (!out) return this.callback(null, source, inputMap);
+  this.callback(null, out.code, out.map);
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@limno/core",
+  "version": "0.1.0",
+  "description": "Limno's framework-neutral dev tooling: JSX source stamping, the change-set store and the endpoints the editor talks to.",
+  "license": "FSL-1.1-MIT",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./loader": "./dist/loader.cjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/armie3/limno.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/armie3/limno#readme",
+  "keywords": [
+    "limno",
+    "design",
+    "visual-editing",
+    "coding-agent",
+    "mcp"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --shims --clean && tsup src/loader.ts --format cjs --out-dir dist --no-clean"
+  },
+  "dependencies": {
+    "@babel/parser": "^7.29.0",
+    "@babel/traverse": "^7.29.0",
+    "@limno/mcp": "0.1.0",
+    "@limno/overlay": "0.1.0",
+    "@limno/spec": "0.1.0",
+    "launch-editor": "^2.14.1",
+    "magic-string": "^0.30.17"
+  },
+  "devDependencies": {
+    "@types/babel__traverse": "^7.20.7"
+  }
+}