@qt-test/apex-dsl-compiler 0.1.0

package/dist/acss/index.js

@@ -0,0 +1,632 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/acss/index.ts
+var acss_exports = {};
+__export(acss_exports, {
+  compileACSS: () => compileACSS,
+  parseACSS: () => parseACSS
+});
+module.exports = __toCommonJS(acss_exports);
+
+// src/acss/parser.ts
+function createPosition(state) {
+  return {
+    line: state.line,
+    column: state.column,
+    offset: state.pos
+  };
+}
+function createLoc(start, end, source) {
+  return { start, end, source };
+}
+function parseACSS(source) {
+  const state = {
+    source,
+    pos: 0,
+    line: 1,
+    column: 0,
+    errors: []
+  };
+  const start = createPosition(state);
+  const rules = [];
+  const imports = [];
+  while (state.pos < state.source.length) {
+    skipWhitespaceAndComments(state);
+    if (state.pos >= state.source.length) break;
+    if (lookAhead(state, "@import")) {
+      const importRule = parseImport(state);
+      if (importRule) {
+        imports.push(importRule);
+      }
+      continue;
+    }
+    if (lookAhead(state, "@media")) {
+      const mediaRule = parseMediaRule(state);
+      if (mediaRule) {
+        rules.push(mediaRule);
+      }
+      continue;
+    }
+    if (lookAhead(state, "@keyframes") || lookAhead(state, "@-webkit-keyframes")) {
+      const keyframesRule = parseKeyframesRule(state);
+      if (keyframesRule) {
+        rules.push(keyframesRule);
+      }
+      continue;
+    }
+    const rule = parseStyleRule(state);
+    if (rule) {
+      rules.push(rule);
+    }
+  }
+  const end = createPosition(state);
+  return {
+    ast: {
+      type: "Stylesheet",
+      rules,
+      imports,
+      start: start.offset,
+      end: end.offset,
+      loc: createLoc(start, end)
+    },
+    errors: state.errors
+  };
+}
+function parseImport(state) {
+  const start = createPosition(state);
+  advance(state, 7);
+  skipWhitespace(state);
+  let path = "";
+  const quote = state.source[state.pos];
+  if (quote === '"' || quote === "'") {
+    advance(state);
+    while (state.pos < state.source.length && state.source[state.pos] !== quote) {
+      path += state.source[state.pos];
+      advance(state);
+    }
+    advance(state);
+  } else {
+    state.errors.push(`Expected quoted string at line ${state.line}`);
+    skipToSemicolon(state);
+    return null;
+  }
+  skipWhitespace(state);
+  consume(state, ";");
+  const end = createPosition(state);
+  return {
+    type: "Import",
+    path,
+    start: start.offset,
+    end: end.offset,
+    loc: createLoc(start, end)
+  };
+}
+function parseMediaRule(state) {
+  const start = createPosition(state);
+  advance(state, 6);
+  skipWhitespace(state);
+  let query = "";
+  while (state.pos < state.source.length && state.source[state.pos] !== "{") {
+    query += state.source[state.pos];
+    advance(state);
+  }
+  query = query.trim();
+  if (!consume(state, "{")) {
+    state.errors.push(`Expected '{' at line ${state.line}`);
+    return null;
+  }
+  const rules = [];
+  while (state.pos < state.source.length && state.source[state.pos] !== "}") {
+    skipWhitespaceAndComments(state);
+    if (state.source[state.pos] === "}") break;
+    const rule = parseStyleRule(state);
+    if (rule) {
+      rules.push(rule);
+    }
+  }
+  consume(state, "}");
+  const end = createPosition(state);
+  return {
+    type: "MediaRule",
+    query,
+    rules,
+    start: start.offset,
+    end: end.offset,
+    loc: createLoc(start, end)
+  };
+}
+function parseKeyframesRule(state) {
+  const start = createPosition(state);
+  if (lookAhead(state, "@-webkit-keyframes")) {
+    advance(state, 18);
+  } else {
+    advance(state, 10);
+  }
+  skipWhitespace(state);
+  let name = "";
+  while (state.pos < state.source.length && !/[\s{]/.test(state.source[state.pos])) {
+    name += state.source[state.pos];
+    advance(state);
+  }
+  skipWhitespace(state);
+  if (!consume(state, "{")) {
+    state.errors.push(`Expected '{' at line ${state.line}`);
+    return null;
+  }
+  const keyframes = [];
+  while (state.pos < state.source.length && state.source[state.pos] !== "}") {
+    skipWhitespaceAndComments(state);
+    if (state.source[state.pos] === "}") break;
+    const keyframe = parseKeyframe(state);
+    if (keyframe) {
+      keyframes.push(keyframe);
+    }
+  }
+  consume(state, "}");
+  const end = createPosition(state);
+  return {
+    type: "KeyframesRule",
+    name,
+    keyframes,
+    start: start.offset,
+    end: end.offset,
+    loc: createLoc(start, end)
+  };
+}
+function parseKeyframe(state) {
+  const start = createPosition(state);
+  let selector = "";
+  while (state.pos < state.source.length && state.source[state.pos] !== "{") {
+    selector += state.source[state.pos];
+    advance(state);
+  }
+  selector = selector.trim();
+  if (!consume(state, "{")) {
+    state.errors.push(`Expected '{' at line ${state.line}`);
+    return null;
+  }
+  const declarations = parseDeclarations(state);
+  consume(state, "}");
+  const end = createPosition(state);
+  return {
+    type: "Keyframe",
+    selector,
+    declarations,
+    start: start.offset,
+    end: end.offset,
+    loc: createLoc(start, end)
+  };
+}
+function parseStyleRule(state) {
+  const start = createPosition(state);
+  const selectors = parseSelectors(state);
+  if (selectors.length === 0) {
+    skipToCloseBrace(state);
+    return null;
+  }
+  skipWhitespace(state);
+  if (!consume(state, "{")) {
+    state.errors.push(`Expected '{' at line ${state.line}`);
+    skipToCloseBrace(state);
+    return null;
+  }
+  const declarations = parseDeclarations(state);
+  consume(state, "}");
+  const end = createPosition(state);
+  return {
+    type: "StyleRule",
+    selectors,
+    declarations,
+    start: start.offset,
+    end: end.offset,
+    loc: createLoc(start, end)
+  };
+}
+function parseSelectors(state) {
+  const selectors = [];
+  let current = "";
+  const start = createPosition(state);
+  while (state.pos < state.source.length) {
+    const char = state.source[state.pos];
+    if (char === "{") break;
+    if (char === ",") {
+      const trimmed2 = current.trim();
+      if (trimmed2) {
+        const end = createPosition(state);
+        selectors.push({
+          type: "Selector",
+          value: trimmed2,
+          specificity: calculateSpecificity(trimmed2),
+          start: start.offset,
+          end: end.offset,
+          loc: createLoc(start, end)
+        });
+      }
+      advance(state);
+      current = "";
+      continue;
+    }
+    current += char;
+    advance(state);
+  }
+  const trimmed = current.trim();
+  if (trimmed) {
+    const end = createPosition(state);
+    selectors.push({
+      type: "Selector",
+      value: trimmed,
+      specificity: calculateSpecificity(trimmed),
+      start: start.offset,
+      end: end.offset,
+      loc: createLoc(start, end)
+    });
+  }
+  return selectors;
+}
+function calculateSpecificity(selector) {
+  let ids = 0;
+  let classes = 0;
+  let elements = 0;
+  ids = (selector.match(/#[a-zA-Z_-][a-zA-Z0-9_-]*/g) || []).length;
+  classes = (selector.match(/\.[a-zA-Z_-][a-zA-Z0-9_-]*/g) || []).length;
+  classes += (selector.match(/\[[^\]]+\]/g) || []).length;
+  classes += (selector.match(/:[a-zA-Z-]+(?:\([^)]*\))?/g) || []).filter(
+    (p) => !p.startsWith("::")
+  ).length;
+  const withoutIds = selector.replace(/#[a-zA-Z_-][a-zA-Z0-9_-]*/g, "");
+  const withoutClasses = withoutIds.replace(/\.[a-zA-Z_-][a-zA-Z0-9_-]*/g, "");
+  const withoutAttrs = withoutClasses.replace(/\[[^\]]+\]/g, "");
+  const withoutPseudo = withoutAttrs.replace(/:[a-zA-Z-]+(?:\([^)]*\))?/g, "");
+  const tagMatches = withoutPseudo.match(/[a-zA-Z][a-zA-Z0-9-]*/g) || [];
+  elements = tagMatches.filter((t) => !["not", "is", "where", "has"].includes(t)).length;
+  elements += (selector.match(/::[a-zA-Z-]+/g) || []).length;
+  return [ids, classes, elements];
+}
+function parseDeclarations(state) {
+  const declarations = [];
+  while (state.pos < state.source.length && state.source[state.pos] !== "}") {
+    skipWhitespaceAndComments(state);
+    if (state.source[state.pos] === "}") break;
+    const declaration = parseDeclaration(state);
+    if (declaration) {
+      declarations.push(declaration);
+    }
+  }
+  return declarations;
+}
+function parseDeclaration(state) {
+  const start = createPosition(state);
+  let property = "";
+  while (state.pos < state.source.length && state.source[state.pos] !== ":" && state.source[state.pos] !== "}") {
+    property += state.source[state.pos];
+    advance(state);
+  }
+  property = property.trim();
+  if (!property || !consume(state, ":")) {
+    skipToSemicolon(state);
+    return null;
+  }
+  skipWhitespace(state);
+  let value = "";
+  let important = false;
+  let parenDepth = 0;
+  while (state.pos < state.source.length) {
+    const char = state.source[state.pos];
+    if (char === "(") parenDepth++;
+    if (char === ")") parenDepth--;
+    if (parenDepth === 0 && (char === ";" || char === "}")) {
+      break;
+    }
+    value += char;
+    advance(state);
+  }
+  value = value.trim();
+  if (value.endsWith("!important")) {
+    important = true;
+    value = value.slice(0, -10).trim();
+  }
+  consume(state, ";");
+  const end = createPosition(state);
+  if (!/^[a-zA-Z-]+$/.test(property)) {
+    state.errors.push(`Invalid property name "${property}" at line ${start.line}`);
+    return null;
+  }
+  return {
+    type: "Declaration",
+    property,
+    value,
+    important,
+    start: start.offset,
+    end: end.offset,
+    loc: createLoc(start, end)
+  };
+}
+function advance(state, count = 1) {
+  for (let i = 0; i < count && state.pos < state.source.length; i++) {
+    if (state.source[state.pos] === "\n") {
+      state.line++;
+      state.column = 0;
+    } else {
+      state.column++;
+    }
+    state.pos++;
+  }
+}
+function lookAhead(state, str) {
+  return state.source.slice(state.pos, state.pos + str.length) === str;
+}
+function consume(state, str) {
+  if (lookAhead(state, str)) {
+    advance(state, str.length);
+    return true;
+  }
+  return false;
+}
+function skipWhitespace(state) {
+  while (state.pos < state.source.length && /\s/.test(state.source[state.pos])) {
+    advance(state);
+  }
+}
+function skipWhitespaceAndComments(state) {
+  while (state.pos < state.source.length) {
+    skipWhitespace(state);
+    if (lookAhead(state, "/*")) {
+      advance(state, 2);
+      while (state.pos < state.source.length && !lookAhead(state, "*/")) {
+        advance(state);
+      }
+      advance(state, 2);
+      continue;
+    }
+    if (lookAhead(state, "//")) {
+      while (state.pos < state.source.length && state.source[state.pos] !== "\n") {
+        advance(state);
+      }
+      continue;
+    }
+    break;
+  }
+}
+function skipToSemicolon(state) {
+  while (state.pos < state.source.length && state.source[state.pos] !== ";" && state.source[state.pos] !== "}") {
+    advance(state);
+  }
+  consume(state, ";");
+}
+function skipToCloseBrace(state) {
+  let depth = 0;
+  while (state.pos < state.source.length) {
+    if (state.source[state.pos] === "{") depth++;
+    if (state.source[state.pos] === "}") {
+      if (depth === 0) {
+        advance(state);
+        return;
+      }
+      depth--;
+    }
+    advance(state);
+  }
+}
+
+// src/acss/compiler.ts
+var PREFIXED_PROPERTIES = {
+  "transform": ["-webkit-transform"],
+  "transform-origin": ["-webkit-transform-origin"],
+  "transition": ["-webkit-transition"],
+  "animation": ["-webkit-animation"],
+  "animation-name": ["-webkit-animation-name"],
+  "animation-duration": ["-webkit-animation-duration"],
+  "animation-timing-function": ["-webkit-animation-timing-function"],
+  "animation-delay": ["-webkit-animation-delay"],
+  "animation-iteration-count": ["-webkit-animation-iteration-count"],
+  "animation-direction": ["-webkit-animation-direction"],
+  "animation-fill-mode": ["-webkit-animation-fill-mode"],
+  "animation-play-state": ["-webkit-animation-play-state"],
+  "flex": ["-webkit-flex"],
+  "flex-direction": ["-webkit-flex-direction"],
+  "flex-wrap": ["-webkit-flex-wrap"],
+  "flex-flow": ["-webkit-flex-flow"],
+  "justify-content": ["-webkit-justify-content"],
+  "align-items": ["-webkit-align-items"],
+  "align-content": ["-webkit-align-content"],
+  "align-self": ["-webkit-align-self"],
+  "order": ["-webkit-order"],
+  "flex-grow": ["-webkit-flex-grow"],
+  "flex-shrink": ["-webkit-flex-shrink"],
+  "flex-basis": ["-webkit-flex-basis"],
+  "user-select": ["-webkit-user-select", "-moz-user-select"],
+  "appearance": ["-webkit-appearance", "-moz-appearance"],
+  "backdrop-filter": ["-webkit-backdrop-filter"],
+  "background-clip": ["-webkit-background-clip"]
+};
+function compileACSS(source, options = {}) {
+  const { ast, errors: parseErrors } = parseACSS(source);
+  const warnings = [];
+  const errors = [...parseErrors];
+  const animations = /* @__PURE__ */ new Set();
+  const imports = ast.imports.map((i) => i.path);
+  const processedRules = ast.rules.map((rule) => processRule(rule, options, animations, warnings));
+  const css = generateCSS(processedRules, options, warnings);
+  return {
+    css,
+    ast,
+    warnings,
+    errors,
+    imports,
+    animations
+  };
+}
+function processRule(rule, options, animations, warnings) {
+  switch (rule.type) {
+    case "StyleRule":
+      return processStyleRule(rule, options, animations, warnings);
+    case "MediaRule":
+      return {
+        ...rule,
+        rules: rule.rules.map((r) => processStyleRule(r, options, animations, warnings))
+      };
+    case "KeyframesRule":
+      animations.add(rule.name);
+      return processKeyframesRule(rule, options, warnings);
+    default:
+      return rule;
+  }
+}
+function processStyleRule(rule, options, animations, warnings) {
+  let selectors = rule.selectors;
+  if (options.scoped && options.scopeId) {
+    selectors = selectors.map((s) => ({
+      ...s,
+      value: scopeSelector(s.value, options.scopeId)
+    }));
+  }
+  let declarations = rule.declarations.map((d) => processDeclaration(d, options, warnings));
+  if (options.autoprefixer) {
+    declarations = addVendorPrefixes(declarations);
+  }
+  declarations.forEach((d) => {
+    if (d.property === "animation" || d.property === "animation-name") {
+      const animName = d.value.split(/\s+/)[0];
+      if (animName && !animName.startsWith("var(")) {
+        animations.add(animName);
+      }
+    }
+  });
+  return {
+    ...rule,
+    selectors,
+    declarations
+  };
+}
+function processKeyframesRule(rule, options, warnings) {
+  return {
+    ...rule,
+    keyframes: rule.keyframes.map((kf) => ({
+      ...kf,
+      declarations: kf.declarations.map((d) => processDeclaration(d, options, warnings))
+    }))
+  };
+}
+function processDeclaration(decl, options, warnings) {
+  let { value } = decl;
+  if (options.rpxToRem) {
+    value = convertRpxToRem(value, options);
+  }
+  if (!value) {
+    warnings.push(`Empty value for property "${decl.property}"`);
+  }
+  return {
+    ...decl,
+    value
+  };
+}
+function convertRpxToRem(value, options) {
+  const designWidth = options.designWidth ?? 750;
+  const baseFontSize = options.baseFontSize ?? 16;
+  return value.replace(/(\d+(?:\.\d+)?)\s*rpx/gi, (_, num) => {
+    const px = parseFloat(num) / designWidth * 375;
+    const rem = px / baseFontSize;
+    return `${rem.toFixed(6).replace(/\.?0+$/, "")}rem`;
+  });
+}
+function scopeSelector(selector, scopeId) {
+  const scopeAttr = `[data-v-${scopeId}]`;
+  return selector.split(/\s*([>+~])\s*/).map((part, i) => {
+    if (i % 2 === 1) return part;
+    if (/^(html|body|:root)$/i.test(part)) return part;
+    const pseudoMatch = part.match(/^(.+?)(::[\w-]+)$/);
+    if (pseudoMatch) {
+      return `${pseudoMatch[1]}${scopeAttr}${pseudoMatch[2]}`;
+    }
+    const pseudoClassMatch = part.match(/^(.+?)(:[\w-]+(?:\([^)]*\))?)$/);
+    if (pseudoClassMatch) {
+      return `${pseudoClassMatch[1]}${scopeAttr}${pseudoClassMatch[2]}`;
+    }
+    return `${part}${scopeAttr}`;
+  }).join(" ");
+}
+function addVendorPrefixes(declarations) {
+  const result = [];
+  for (const decl of declarations) {
+    const prefixes = PREFIXED_PROPERTIES[decl.property];
+    if (prefixes) {
+      for (const prefix of prefixes) {
+        result.push({
+          ...decl,
+          property: prefix
+        });
+      }
+    }
+    result.push(decl);
+  }
+  return result;
+}
+function generateCSS(rules, options, _warnings) {
+  const minify = options.minify ?? false;
+  const indent = minify ? "" : "  ";
+  const newline = minify ? "" : "\n";
+  const space = minify ? "" : " ";
+  const parts = [];
+  for (const rule of rules) {
+    parts.push(generateRule(rule, indent, newline, space));
+  }
+  return parts.join(minify ? "" : "\n\n");
+}
+function generateRule(rule, indent, newline, space) {
+  switch (rule.type) {
+    case "StyleRule":
+      return generateStyleRule(rule, indent, newline, space);
+    case "MediaRule":
+      return generateMediaRule(rule, indent, newline, space);
+    case "KeyframesRule":
+      return generateKeyframesRule(rule, indent, newline, space);
+    default:
+      return "";
+  }
+}
+function generateStyleRule(rule, indent, newline, space, baseIndent = "") {
+  const selectors = rule.selectors.map((s) => s.value).join(`,${space}`);
+  const declarations = rule.declarations.map((d) => {
+    const important = d.important ? `${space}!important` : "";
+    return `${baseIndent}${indent}${d.property}:${space}${d.value}${important};`;
+  }).join(newline);
+  return `${baseIndent}${selectors}${space}{${newline}${declarations}${newline}${baseIndent}}`;
+}
+function generateMediaRule(rule, indent, newline, space) {
+  const rules = rule.rules.map((r) => generateStyleRule(r, indent, newline, space, indent)).join(newline + newline);
+  return `@media${space}${rule.query}${space}{${newline}${rules}${newline}}`;
+}
+function generateKeyframesRule(rule, indent, newline, space) {
+  const keyframes = rule.keyframes.map((kf) => {
+    const declarations = kf.declarations.map((d) => {
+      const important = d.important ? `${space}!important` : "";
+      return `${indent}${indent}${d.property}:${space}${d.value}${important};`;
+    }).join(newline);
+    return `${indent}${kf.selector}${space}{${newline}${declarations}${newline}${indent}}`;
+  }).join(newline);
+  const standard = `@keyframes${space}${rule.name}${space}{${newline}${keyframes}${newline}}`;
+  const webkit = `@-webkit-keyframes${space}${rule.name}${space}{${newline}${keyframes}${newline}}`;
+  return `${webkit}${newline}${standard}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileACSS,
+  parseACSS
+});

package/dist/acss/index.mjs

@@ -0,0 +1,8 @@
+import {
+  compileACSS,
+  parseACSS
+} from "../chunk-B7VE6TVQ.mjs";
+export {
+  compileACSS,
+  parseACSS
+};