@qt-test/apex-dsl-compiler 0.1.0

package/dist/index.mjs

@@ -0,0 +1,587 @@
+import {
+  compileACSS,
+  parseACSS
+} from "./chunk-B7VE6TVQ.mjs";
+import {
+  compileAXML,
+  parseAXML
+} from "./chunk-GQ3PJZ2P.mjs";
+
+// src/codegen.ts
+function generateCode(input, options) {
+  const { template, styles, js } = input;
+  const { isComponent, minify } = options;
+  const parts = [];
+  parts.push(generateImports(input, options));
+  if (js) {
+    parts.push("");
+    parts.push("// User code");
+    parts.push(js);
+  }
+  if (template) {
+    parts.push("");
+    parts.push("// Render function");
+    parts.push(template.code);
+  }
+  if (styles) {
+    parts.push("");
+    parts.push("// Styles");
+    parts.push(generateStylesCode(styles, options));
+  }
+  parts.push("");
+  parts.push(
+    isComponent ? generateComponentDefinition(input, options) : generatePageDefinition(input, options)
+  );
+  parts.push("");
+  parts.push(generateExports(input, options));
+  let code = parts.join("\n");
+  if (minify) {
+    code = minifyCode(code);
+  }
+  return code;
+}
+function generateImports(input, _options) {
+  const imports = [];
+  const runtimeImports = ["h", "Fragment"];
+  if (input.template?.usedComponents.size) {
+    runtimeImports.push("resolveComponent");
+  }
+  if (input.template?.code.includes("renderList")) {
+    runtimeImports.push("renderList");
+  }
+  if (input.template?.code.includes("renderSlot")) {
+    runtimeImports.push("renderSlot");
+  }
+  imports.push(`import { ${runtimeImports.join(", ")} } from '@qt-test/apex-runtime';`);
+  const components = input.config.usingComponents ?? {};
+  for (const [name, path] of Object.entries(components)) {
+    imports.push(`import ${toPascalCase(name)} from '${path}';`);
+  }
+  if (input.styles?.imports.length) {
+    for (const importPath of input.styles.imports) {
+      imports.push(`import '${importPath}';`);
+    }
+  }
+  return imports.join("\n");
+}
+function generateStylesCode(styles, _options) {
+  const css = styles.css.replace(/`/g, "\\`").replace(/\$/g, "\\$");
+  return `const __styles__ = \`${css}\`;`;
+}
+function generateComponentDefinition(input, _options) {
+  const properties = extractComponentProperties(input.js ?? "");
+  const methods = extractComponentMethods(input.js ?? "");
+  const parts = [];
+  parts.push("const __component__ = {");
+  parts.push('  is: "component",');
+  if (properties.length > 0) {
+    parts.push(`  properties: {`);
+    for (const prop of properties) {
+      parts.push(`    ${prop.name}: { type: ${prop.type}, value: ${prop.default} },`);
+    }
+    parts.push("  },");
+  }
+  parts.push("  data() {");
+  parts.push("    return {};");
+  parts.push("  },");
+  if (methods.length > 0) {
+    parts.push("  methods: {");
+    for (const method of methods) {
+      parts.push(`    ${method},`);
+    }
+    parts.push("  },");
+  }
+  if (input.template) {
+    parts.push("  render,");
+  }
+  if (input.styles) {
+    parts.push("  styles: __styles__,");
+  }
+  if (input.config.usingComponents) {
+    const componentEntries = Object.entries(input.config.usingComponents).map(([name]) => `    "${name}": ${toPascalCase(name)}`).join(",\n");
+    parts.push(`  components: {
+${componentEntries}
+  },`);
+  }
+  parts.push("};");
+  return parts.join("\n");
+}
+function generatePageDefinition(input, _options) {
+  const parts = [];
+  parts.push("const __page__ = {");
+  parts.push('  is: "page",');
+  if (input.config.navigationBarTitleText) {
+    parts.push(`  title: "${input.config.navigationBarTitleText}",`);
+  }
+  if (input.config.enablePullDownRefresh) {
+    parts.push("  enablePullDownRefresh: true,");
+  }
+  parts.push("  data() {");
+  parts.push("    return {};");
+  parts.push("  },");
+  if (input.template) {
+    parts.push("  render,");
+  }
+  if (input.styles) {
+    parts.push("  styles: __styles__,");
+  }
+  if (input.config.usingComponents) {
+    const componentEntries = Object.entries(input.config.usingComponents).map(([name]) => `    "${name}": ${toPascalCase(name)}`).join(",\n");
+    parts.push(`  components: {
+${componentEntries}
+  },`);
+  }
+  parts.push("};");
+  return parts.join("\n");
+}
+function generateExports(input, options) {
+  const exports = [];
+  if (options.isComponent) {
+    exports.push("export default __component__;");
+  } else {
+    exports.push("export default __page__;");
+  }
+  if (input.template) {
+    exports.push("export { render };");
+  }
+  if (input.styles) {
+    exports.push("export { __styles__ as styles };");
+  }
+  return exports.join("\n");
+}
+function extractComponentProperties(js) {
+  const properties = [];
+  const propsMatch = js.match(/properties\s*:\s*\{([^}]+)\}/);
+  if (propsMatch) {
+    const propsBlock = propsMatch[1];
+    const propMatches = propsBlock.matchAll(/(\w+)\s*:\s*\{?\s*(?:type\s*:\s*(\w+))?\s*(?:,\s*value\s*:\s*([^,}]+))?\s*\}?/g);
+    for (const match of propMatches) {
+      properties.push({
+        name: match[1],
+        type: match[2] || "String",
+        default: match[3]?.trim() || "null"
+      });
+    }
+  }
+  return properties;
+}
+function extractComponentMethods(js) {
+  const methods = [];
+  const methodsMatch = js.match(/methods\s*:\s*\{([^}]+(?:\{[^}]*\}[^}]*)*)\}/);
+  if (methodsMatch) {
+    const methodsBlock = methodsMatch[1];
+    const methodMatches = methodsBlock.matchAll(/(\w+)\s*(?:\([^)]*\))?\s*\{/g);
+    for (const match of methodMatches) {
+      methods.push(match[1]);
+    }
+  }
+  return methods;
+}
+function toPascalCase(str) {
+  return str.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function minifyCode(code) {
+  return code.replace(/\/\/.*$/gm, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").replace(/\s*([{};,:])\s*/g, "$1").replace(/;\s*}/g, "}").trim();
+}
+
+// src/sourcemap.ts
+var SourceMapBuilder = class {
+  constructor(options) {
+    this.sources = [];
+    this.sourcesContent = [];
+    this.names = [];
+    this.mappings = [];
+    this.currentLine = [];
+    if (options) {
+      this.file = options.file;
+      this.sourceRoot = options.sourceRoot;
+      this.sources = [...options.sources];
+      if (options.includeContent && options.sourcesContent) {
+        this.sourcesContent = [...options.sourcesContent];
+      }
+    }
+  }
+  /**
+   * Adds a source file
+   */
+  addSource(source, content) {
+    const index = this.sources.indexOf(source);
+    if (index !== -1) {
+      return index;
+    }
+    this.sources.push(source);
+    this.sourcesContent.push(content ?? null);
+    return this.sources.length - 1;
+  }
+  /**
+   * Adds a name
+   */
+  addName(name) {
+    const index = this.names.indexOf(name);
+    if (index !== -1) {
+      return index;
+    }
+    this.names.push(name);
+    return this.names.length - 1;
+  }
+  /**
+   * Adds a mapping
+   */
+  addMapping(generatedLine, generatedColumn, sourceIndex, sourceLine, sourceColumn, nameIndex) {
+    while (this.mappings.length <= generatedLine) {
+      if (this.currentLine.length > 0) {
+        this.mappings.push(this.currentLine);
+        this.currentLine = [];
+      } else {
+        this.mappings.push([]);
+      }
+    }
+    const segment = { generatedColumn };
+    if (sourceIndex !== void 0) {
+      segment.sourceIndex = sourceIndex;
+      segment.sourceLine = sourceLine;
+      segment.sourceColumn = sourceColumn;
+      if (nameIndex !== void 0) {
+        segment.nameIndex = nameIndex;
+      }
+    }
+    if (this.mappings.length === generatedLine) {
+      this.currentLine.push(segment);
+    } else {
+      this.mappings[generatedLine].push(segment);
+    }
+  }
+  /**
+   * Starts a new line
+   */
+  newLine() {
+    this.mappings.push(this.currentLine);
+    this.currentLine = [];
+  }
+  /**
+   * Generates the source map
+   */
+  toSourceMap() {
+    if (this.currentLine.length > 0) {
+      this.mappings.push(this.currentLine);
+      this.currentLine = [];
+    }
+    return {
+      version: 3,
+      file: this.file,
+      sourceRoot: this.sourceRoot,
+      sources: this.sources,
+      sourcesContent: this.sourcesContent.length > 0 ? this.sourcesContent : void 0,
+      names: this.names,
+      mappings: this.encodeMappings()
+    };
+  }
+  /**
+   * Encodes mappings to VLQ format
+   */
+  encodeMappings() {
+    let previousGeneratedColumn = 0;
+    let previousSourceIndex = 0;
+    let previousSourceLine = 0;
+    let previousSourceColumn = 0;
+    let previousNameIndex = 0;
+    const lines = [];
+    for (const line of this.mappings) {
+      previousGeneratedColumn = 0;
+      const segments = [];
+      const sortedSegments = [...line].sort((a, b) => a.generatedColumn - b.generatedColumn);
+      for (const segment of sortedSegments) {
+        const values = [];
+        values.push(segment.generatedColumn - previousGeneratedColumn);
+        previousGeneratedColumn = segment.generatedColumn;
+        if (segment.sourceIndex !== void 0) {
+          values.push(segment.sourceIndex - previousSourceIndex);
+          previousSourceIndex = segment.sourceIndex;
+          values.push((segment.sourceLine ?? 0) - previousSourceLine);
+          previousSourceLine = segment.sourceLine ?? 0;
+          values.push((segment.sourceColumn ?? 0) - previousSourceColumn);
+          previousSourceColumn = segment.sourceColumn ?? 0;
+          if (segment.nameIndex !== void 0) {
+            values.push(segment.nameIndex - previousNameIndex);
+            previousNameIndex = segment.nameIndex;
+          }
+        }
+        segments.push(values.map(encodeVLQ).join(""));
+      }
+      lines.push(segments.join(","));
+    }
+    return lines.join(";");
+  }
+  /**
+   * Returns JSON string
+   */
+  toString() {
+    return JSON.stringify(this.toSourceMap());
+  }
+  /**
+   * Returns data URL
+   */
+  toDataUrl() {
+    const json = this.toString();
+    const base64 = typeof btoa !== "undefined" ? btoa(json) : Buffer.from(json).toString("base64");
+    return `data:application/json;charset=utf-8;base64,${base64}`;
+  }
+  /**
+   * Returns inline comment
+   */
+  toComment() {
+    return `//# sourceMappingURL=${this.toDataUrl()}`;
+  }
+};
+var VLQ_BASE64 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var VLQ_BASE_SHIFT = 5;
+var VLQ_BASE = 1 << VLQ_BASE_SHIFT;
+var VLQ_BASE_MASK = VLQ_BASE - 1;
+var VLQ_CONTINUATION_BIT = VLQ_BASE;
+function encodeVLQ(value) {
+  let encoded = "";
+  let vlq = value < 0 ? (-value << 1) + 1 : value << 1;
+  do {
+    let digit = vlq & VLQ_BASE_MASK;
+    vlq >>>= VLQ_BASE_SHIFT;
+    if (vlq > 0) {
+      digit |= VLQ_CONTINUATION_BIT;
+    }
+    encoded += VLQ_BASE64[digit];
+  } while (vlq > 0);
+  return encoded;
+}
+function decodeVLQ(encoded, start = 0) {
+  let vlq = 0;
+  let shift = 0;
+  let continuation = true;
+  let i = start;
+  while (continuation && i < encoded.length) {
+    const char = encoded[i];
+    const digit = VLQ_BASE64.indexOf(char);
+    if (digit === -1) {
+      throw new Error(`Invalid VLQ character: ${char}`);
+    }
+    continuation = (digit & VLQ_CONTINUATION_BIT) !== 0;
+    vlq += (digit & VLQ_BASE_MASK) << shift;
+    shift += VLQ_BASE_SHIFT;
+    i++;
+  }
+  const value = vlq & 1 ? -(vlq >> 1) : vlq >> 1;
+  return { value, next: i };
+}
+function createSourceMap(options) {
+  const builder = new SourceMapBuilder(options);
+  return builder.toSourceMap();
+}
+function mergeSourceMaps(maps) {
+  const builder = new SourceMapBuilder();
+  let lineOffset = 0;
+  for (const map of maps) {
+    const sourceIndexMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < map.sources.length; i++) {
+      const newIndex = builder.addSource(
+        map.sources[i],
+        map.sourcesContent?.[i] ?? void 0
+      );
+      sourceIndexMap.set(i, newIndex);
+    }
+    const nameIndexMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < map.names.length; i++) {
+      const newIndex = builder.addName(map.names[i]);
+      nameIndexMap.set(i, newIndex);
+    }
+    const decodedMappings = decodeMappings(map.mappings);
+    for (let lineIndex = 0; lineIndex < decodedMappings.length; lineIndex++) {
+      const line = decodedMappings[lineIndex];
+      for (const segment of line) {
+        const sourceIndex = segment.sourceIndex !== void 0 ? sourceIndexMap.get(segment.sourceIndex) : void 0;
+        const nameIndex = segment.nameIndex !== void 0 ? nameIndexMap.get(segment.nameIndex) : void 0;
+        builder.addMapping(
+          lineIndex + lineOffset,
+          segment.generatedColumn,
+          sourceIndex,
+          segment.sourceLine,
+          segment.sourceColumn,
+          nameIndex
+        );
+      }
+    }
+    lineOffset += decodedMappings.length;
+  }
+  return builder.toSourceMap();
+}
+function decodeMappings(mappings) {
+  const lines = [];
+  const lineStrings = mappings.split(";");
+  let previousSourceIndex = 0;
+  let previousSourceLine = 0;
+  let previousSourceColumn = 0;
+  let previousNameIndex = 0;
+  for (const lineString of lineStrings) {
+    const line = [];
+    let previousGeneratedColumn = 0;
+    if (lineString) {
+      const segmentStrings = lineString.split(",");
+      for (const segmentString of segmentStrings) {
+        if (!segmentString) continue;
+        const segment = { generatedColumn: 0 };
+        let pos = 0;
+        const col = decodeVLQ(segmentString, pos);
+        segment.generatedColumn = previousGeneratedColumn + col.value;
+        previousGeneratedColumn = segment.generatedColumn;
+        pos = col.next;
+        if (pos < segmentString.length) {
+          const src = decodeVLQ(segmentString, pos);
+          segment.sourceIndex = previousSourceIndex + src.value;
+          previousSourceIndex = segment.sourceIndex;
+          pos = src.next;
+          const srcLine = decodeVLQ(segmentString, pos);
+          segment.sourceLine = previousSourceLine + srcLine.value;
+          previousSourceLine = segment.sourceLine;
+          pos = srcLine.next;
+          const srcCol = decodeVLQ(segmentString, pos);
+          segment.sourceColumn = previousSourceColumn + srcCol.value;
+          previousSourceColumn = segment.sourceColumn;
+          pos = srcCol.next;
+          if (pos < segmentString.length) {
+            const name = decodeVLQ(segmentString, pos);
+            segment.nameIndex = previousNameIndex + name.value;
+            previousNameIndex = segment.nameIndex;
+          }
+        }
+        line.push(segment);
+      }
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+function applySourceMap(map, line, column) {
+  const decodedMappings = decodeMappings(map.mappings);
+  if (line >= decodedMappings.length) {
+    return null;
+  }
+  const lineMappings = decodedMappings[line];
+  let bestSegment = null;
+  for (const segment of lineMappings) {
+    if (segment.generatedColumn <= column) {
+      bestSegment = segment;
+    } else {
+      break;
+    }
+  }
+  if (!bestSegment || bestSegment.sourceIndex === void 0) {
+    return null;
+  }
+  return {
+    source: map.sources[bestSegment.sourceIndex] ?? null,
+    line: bestSegment.sourceLine ?? 0,
+    column: bestSegment.sourceColumn ?? 0,
+    name: bestSegment.nameIndex !== void 0 ? map.names[bestSegment.nameIndex] ?? null : null
+  };
+}
+
+// src/compiler.ts
+function compile(options) {
+  const warnings = [];
+  const errors = [];
+  let config = {};
+  if (options.json) {
+    if (typeof options.json === "string") {
+      try {
+        config = JSON.parse(options.json);
+      } catch (e) {
+        errors.push({
+          code: "INVALID_JSON",
+          message: `Failed to parse JSON config: ${e.message}`
+        });
+      }
+    } else {
+      config = options.json;
+    }
+  }
+  const isComponent = options.isComponent ?? config.component ?? false;
+  let templateResult = null;
+  if (options.axml) {
+    templateResult = compileAXML(options.axml, {
+      filename: options.filename ? `${options.filename}.axml` : void 0,
+      components: { ...config.usingComponents, ...options.components }
+    });
+    warnings.push(...templateResult.warnings.map((w) => ({ message: w })));
+    errors.push(...templateResult.errors.map((e) => ({ code: "AXML_ERROR", message: e })));
+  }
+  let styleResult = null;
+  if (options.acss) {
+    styleResult = compileACSS(options.acss, {
+      filename: options.filename ? `${options.filename}.acss` : void 0
+    });
+    warnings.push(...styleResult.warnings.map((w) => ({ message: w })));
+    errors.push(...styleResult.errors.map((e) => ({ code: "ACSS_ERROR", message: e })));
+  }
+  const generatorOptions = {
+    isComponent,
+    minify: options.minify ?? false,
+    target: options.target ?? "es2020",
+    sourceMap: options.sourceMap ?? false,
+    filename: options.filename
+  };
+  const code = generateCode({
+    template: templateResult,
+    styles: styleResult,
+    config,
+    js: options.js
+  }, generatorOptions);
+  let map;
+  if (options.sourceMap && options.filename) {
+    map = createSourceMap({
+      file: options.filename,
+      sources: [
+        options.axml ? `${options.filename}.axml` : null,
+        options.acss ? `${options.filename}.acss` : null,
+        options.js ? `${options.filename}.js` : null
+      ].filter(Boolean)
+    });
+  }
+  return {
+    code,
+    css: styleResult?.css ?? "",
+    config,
+    map,
+    warnings,
+    errors,
+    templateAst: templateResult?.ast,
+    styleAst: styleResult?.ast
+  };
+}
+function validate(result) {
+  return result.errors.length === 0;
+}
+function formatErrors(result) {
+  if (result.errors.length === 0) return "";
+  return result.errors.map((error) => {
+    let msg = `[${error.code}] ${error.message}`;
+    if (error.loc) {
+      msg += ` at line ${error.loc.line}, column ${error.loc.column}`;
+    }
+    return msg;
+  }).join("\n");
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  SourceMapBuilder,
+  VERSION,
+  applySourceMap,
+  compile,
+  compileACSS,
+  compileAXML,
+  createSourceMap,
+  formatErrors,
+  generateCode,
+  mergeSourceMaps,
+  parseACSS,
+  parseAXML,
+  validate
+};

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@qt-test/apex-dsl-compiler",
+  "version": "0.1.0",
+  "private": false,
+  "description": "AXML/ACSS DSL compiler for APEX mini-app platform",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/nicholasodion/apex-compiler.git"
+  },
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "apexc": "./bin/apexc.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./axml": {
+      "import": "./dist/axml/index.mjs",
+      "require": "./dist/axml/index.js",
+      "types": "./dist/axml/index.d.ts"
+    },
+    "./acss": {
+      "import": "./dist/acss/index.mjs",
+      "require": "./dist/acss/index.js",
+      "types": "./dist/acss/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts src/axml/index.ts src/acss/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts src/axml/index.ts src/acss/index.ts --format cjs,esm --dts --watch",
+    "lint": "eslint src/",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "apex",
+    "miniapp",
+    "compiler",
+    "axml",
+    "acss",
+    "dsl"
+  ],
+  "author": "Interswitch",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@qt-test/apex-bridge": "^0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@vitest/coverage-v8": "^1.0.0",
+    "eslint": "^8.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^1.0.0"
+  }
+}