@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/assets.js

@@ -0,0 +1,155 @@
+import fs from "node:fs";
+import path from "node:path";
+import { createHighlighter } from "ts-syntax-highlighter";
+import { config } from "./config.js";
+import { parseFrontmatter, parseMarkdown } from "./internal-markdown.js";
+import { createDetailedErrorMessage, fileExists } from "./utils.js";
+export const markdownCache = new Map;
+export async function readMarkdownFile(filePath, options = {}) {
+  try {
+    if (!await fileExists(filePath))
+      throw Error(`Markdown file not found: ${filePath}`);
+    const mtime = (await fs.promises.stat(filePath)).mtime.getTime();
+    if (options.cache && markdownCache.has(filePath)) {
+      const cached = markdownCache.get(filePath);
+      if (cached.updatedAt >= mtime)
+        return {
+          content: cached.content,
+          data: cached.data
+        };
+    }
+    const fileContent = await Bun.file(filePath).text(), { data, content: markdownContent } = parseFrontmatter(fileContent), markdownConfig = options.markdown || config.markdown || {
+      enabled: !0,
+      syntaxHighlighting: {
+        enabled: !0,
+        serverSide: !0,
+        defaultTheme: "github-dark",
+        highlightUnknownLanguages: !0
+      }
+    };
+    let htmlContent = parseMarkdown(markdownContent, { gfm: !0 });
+    if (markdownConfig.syntaxHighlighting?.enabled && markdownConfig.syntaxHighlighting?.serverSide)
+      htmlContent = await applyCodeHighlighting(htmlContent, markdownConfig.syntaxHighlighting?.defaultTheme || "github-dark", markdownConfig.syntaxHighlighting?.highlightUnknownLanguages || !1);
+    const parsedResult = {
+      content: htmlContent,
+      data: data || {}
+    };
+    if (options.cache)
+      markdownCache.set(filePath, {
+        ...parsedResult,
+        updatedAt: mtime
+      });
+    return parsedResult;
+  } catch (error) {
+    if (options.debug)
+      console.error(`Error reading/parsing markdown file ${filePath}:`, error);
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      content: createDetailedErrorMessage("Markdown File", `Error reading/parsing markdown file: ${errorMessage}`, filePath, "", 0, ""),
+      data: {}
+    };
+  }
+}
+let highlighterCache = null;
+async function applyCodeHighlighting(html, theme, highlightUnknown) {
+  const codeRegex = /<pre><code( class="language-([^"]+)")?>([^<]+)<\/code><\/pre>/g;
+  if (!highlighterCache)
+    try {
+      highlighterCache = await createHighlighter({
+        theme: theme || "github-dark",
+        cache: !0
+      });
+    } catch (err) {
+      console.error("Failed to initialize ts-syntax-highlighter:", err);
+      return html;
+    }
+  const processCodeBlock = async (match, languageClass, language, code) => {
+    const decodedCode = code.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&").replace(/&quot;/g, '"').replace(/&#39;/g, "'"), langToUse = language || (highlightUnknown ? "text" : "");
+    if (!langToUse)
+      return match;
+    try {
+      if (!highlighterCache.getSupportedLanguages().includes(langToUse))
+        return match;
+      return (await highlighterCache.highlight(decodedCode, langToUse, {
+        theme
+      })).html;
+    } catch (err) {
+      console.error(`Error highlighting code block with language ${language}:`, err);
+    }
+    return match;
+  };
+  let result = html;
+  const matches = html.matchAll(codeRegex);
+  for (const match of matches) {
+    const [fullMatch, languageClass, language, code] = match, highlightedBlock = await processCodeBlock(fullMatch, languageClass, language, code);
+    result = result.replace(fullMatch, highlightedBlock);
+  }
+  return result;
+}
+export async function processMarkdownFileDirectives(template, context, filePath = "", options = {}) {
+  return await replaceAsync(template, /@markdown-file\(\s*['"]([^'"]+)['"]\s*(?:,\s*(\{[^}]*\}))?\)/g, async (match, mdFilePath, contextStr, offset) => {
+    try {
+      let resolvedPath = mdFilePath;
+      if (!path.isAbsolute(mdFilePath))
+        resolvedPath = path.resolve(path.dirname(filePath), mdFilePath);
+      let additionalContext = {};
+      if (contextStr)
+        try {
+          try {
+            additionalContext = JSON.parse(contextStr);
+          } catch {
+            if (options.debug)
+              console.warn("Using safer alternative for parsing JS object literal");
+            const entries = contextStr.replace(/^\s*\{|\}\s*$/g, "").trim().split(/,(?=\s*\w+\s*:)/);
+            for (const entry of entries) {
+              const colonIndex = entry.indexOf(":");
+              if (colonIndex > 0) {
+                const key = entry.substring(0, colonIndex).trim();
+                let value = entry.substring(colonIndex + 1).trim();
+                const hasDoubleQuotes = value.startsWith('"') && value.endsWith('"'), hasSingleQuotes = value.startsWith("'") && value.endsWith("'");
+                if (hasDoubleQuotes || hasSingleQuotes)
+                  value = value.substring(1, value.length - 1);
+                additionalContext[key] = value;
+              }
+            }
+          }
+        } catch (contextError) {
+          if (options.debug)
+            console.error("Error parsing context in @markdown-file directive:", contextError);
+        }
+      const { content, data } = await readMarkdownFile(resolvedPath, options), mergedContext = {
+        ...context,
+        ...data,
+        ...additionalContext
+      };
+      let processedContent = content;
+      const expressionRegex = /\{\{([^}]+)\}\}/g;
+      processedContent = processedContent.replace(expressionRegex, (exprMatch, exprKey) => {
+        const trimmedKey = exprKey.trim();
+        return mergedContext[trimmedKey] !== void 0 ? String(mergedContext[trimmedKey]) : exprMatch;
+      });
+      return processedContent;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return createDetailedErrorMessage("Markdown File", `Error including markdown file: ${errorMessage}`, filePath, template, offset, match);
+    }
+  });
+}
+async function replaceAsync(str, regex, asyncFn) {
+  const promises = [];
+  let match;
+  while ((match = regex.exec(str)) !== null) {
+    const matchText = match[0], matchIndex = match.index, args = match;
+    promises.push(asyncFn(...args).then((replacement) => ({
+      match: matchText,
+      replacement,
+      index: matchIndex
+    })));
+  }
+  const results = await Promise.all(promises);
+  results.sort((a, b) => b.index - a.index);
+  let result = str;
+  for (const { match, replacement } of results)
+    result = result.replace(match, () => replacement);
+  return result;
+}

package/dist/ast.d.ts

@@ -0,0 +1,265 @@
+import type { Position } from './source-maps';
+// =============================================================================
+// Node Guards
+// =============================================================================
+export declare function isDocumentNode(node: ASTNode): node is DocumentNode;
+export declare function isTextNode(node: ASTNode): node is TextNode;
+export declare function isExpressionNode(node: ASTNode): node is ExpressionNode;
+export declare function isDirectiveNode(node: ASTNode): node is DirectiveNode;
+export declare function isComponentNode(node: ASTNode): node is ComponentNode;
+export declare function isElementNode(node: ASTNode): node is ElementNode;
+export declare function isAttributeNode(node: ASTNode): node is AttributeNode;
+export declare function isCommentNode(node: ASTNode): node is CommentNode;
+export declare function isScriptNode(node: ASTNode): node is ScriptNode;
+export declare function isStyleNode(node: ASTNode): node is StyleNode;
+/**
+ * Create a document node
+ */
+export declare function createDocument(children?: ASTNode[], loc?: SourceLocation): DocumentNode;
+/**
+ * Create a text node
+ */
+export declare function createText(value: string, loc?: SourceLocation): TextNode;
+/**
+ * Create an expression node
+ */
+export declare function createExpression(expression: string, escaped?: boolean, loc?: SourceLocation): ExpressionNode;
+/**
+ * Create a directive node
+ */
+export declare function createDirective(name: string, params?: string | null, body?: ASTNode[] | null, loc?: SourceLocation): DirectiveNode;
+/**
+ * Create a component node
+ */
+export declare function createComponent(name: string, attributes?: AttributeNode[], children?: ASTNode[], selfClosing?: boolean, loc?: SourceLocation): ComponentNode;
+/**
+ * Create an element node
+ */
+export declare function createElement(tag: string, attributes?: AttributeNode[], children?: ASTNode[], loc?: SourceLocation): ElementNode;
+/**
+ * Create an attribute node
+ */
+export declare function createAttribute(name: string, value?: string | ExpressionNode | null, loc?: SourceLocation): AttributeNode;
+/**
+ * Create a comment node
+ */
+export declare function createComment(value: string, style?: 'html' | 'stx', loc?: SourceLocation): CommentNode;
+/**
+ * Create a script node
+ */
+export declare function createScript(content: string, attributes?: AttributeNode[], loc?: SourceLocation): ScriptNode;
+/**
+ * Create a style node
+ */
+export declare function createStyle(content: string, attributes?: AttributeNode[], scoped?: boolean, loc?: SourceLocation): StyleNode;
+/**
+ * Walk the AST and call visitor callbacks
+ */
+export declare function walkAST(node: ASTNode, visitor: ASTVisitor, parent?: ASTNode | null): void;
+/**
+ * Get child nodes of a node
+ */
+export declare function getChildren(node: ASTNode): ASTNode[];
+/**
+ * Clone an AST node deeply
+ */
+export declare function cloneNode<T extends ASTNode>(node: T): T;
+/**
+ * Replace a node in the AST
+ */
+export declare function replaceNode(root: DocumentNode, target: ASTNode, replacement: ASTNode | ASTNode[]): void;
+/**
+ * Remove a node from the AST
+ */
+export declare function removeNode(root: DocumentNode, target: ASTNode): void;
+/**
+ * Find all nodes matching a predicate
+ */
+export declare function findNodes(root: ASTNode, predicate: (node: ASTNode) => boolean): ASTNode[];
+/**
+ * Find all nodes of a specific type
+ */
+export declare function findNodesByType<T extends ASTNode['type']>(root: ASTNode, type: T): Extract<ASTNode, { type: T }>[];
+/**
+ * Find all directives by name
+ */
+export declare function findDirectives(root: ASTNode, name: string): DirectiveNode[];
+/**
+ * Find all components by name
+ */
+export declare function findComponents(root: ASTNode, name: string): ComponentNode[];
+/**
+ * Find all elements by tag name
+ */
+export declare function findElements(root: ASTNode, tag: string): ElementNode[];
+/**
+ * Get all expression nodes in the AST
+ */
+export declare function getExpressions(root: ASTNode): ExpressionNode[];
+/**
+ * Get all directive names used in the template
+ */
+export declare function getDirectiveNames(root: ASTNode): Set<string>;
+/**
+ * Get all component names used in the template
+ */
+export declare function getComponentNames(root: ASTNode): Set<string>;
+/**
+ * Generate code from AST
+ */
+export declare function generateCode(node: ASTNode): string;
+/**
+ * Source location in template
+ */
+export declare interface SourceLocation {
+  start: Position
+  end: Position
+  source?: string
+}
+/**
+ * Base interface for all AST nodes
+ */
+export declare interface BaseNode {
+  type: string
+  loc?: SourceLocation
+  parent?: ASTNode
+}
+/**
+ * Document root node
+ */
+export declare interface DocumentNode extends BaseNode {
+  type: 'Document'
+  children: ASTNode[]
+}
+/**
+ * Plain text content
+ */
+export declare interface TextNode extends BaseNode {
+  type: 'Text'
+  value: string
+}
+/**
+ * Expression interpolation: {{ expr }} or {!! expr !!}
+ */
+export declare interface ExpressionNode extends BaseNode {
+  type: 'Expression'
+  expression: string
+  escaped: boolean
+  raw: string
+}
+/**
+ * Directive: @name(params) ... @endname
+ */
+export declare interface DirectiveNode extends BaseNode {
+  type: 'Directive'
+  name: string
+  params: string | null
+  body: ASTNode[] | null
+  selfClosing: boolean
+  raw: string
+}
+/**
+ * Component: <ComponentName attr="value">...</ComponentName>
+ */
+export declare interface ComponentNode extends BaseNode {
+  type: 'Component'
+  name: string
+  attributes: AttributeNode[]
+  children: ASTNode[]
+  selfClosing: boolean
+}
+/**
+ * HTML Element: <tag attr="value">...</tag>
+ */
+export declare interface ElementNode extends BaseNode {
+  type: 'Element'
+  tag: string
+  attributes: AttributeNode[]
+  children: ASTNode[]
+  selfClosing: boolean
+  void: boolean
+}
+/**
+ * Attribute on element or component
+ */
+export declare interface AttributeNode extends BaseNode {
+  type: 'Attribute'
+  name: string
+  value: string | ExpressionNode | null
+  dynamic: boolean
+}
+/**
+ * Comment: <!-- comment --> or {{-- comment --}}
+ */
+export declare interface CommentNode extends BaseNode {
+  type: 'Comment'
+  value: string
+  style: 'html' | 'stx'
+}
+/**
+ * Script block: <script>...</script>
+ */
+export declare interface ScriptNode extends BaseNode {
+  type: 'Script'
+  content: string
+  attributes: AttributeNode[]
+}
+/**
+ * Style block: <style>...</style>
+ */
+export declare interface StyleNode extends BaseNode {
+  type: 'Style'
+  content: string
+  attributes: AttributeNode[]
+  scoped: boolean
+}
+/**
+ * Visitor callbacks for AST traversal
+ */
+export declare interface ASTVisitor {
+  enter?: (node: ASTNode, parent: ASTNode | null) => void | false
+  leave?: (node: ASTNode, parent: ASTNode | null) => void
+  Document?: { enter?: (node: DocumentNode) => void | false, leave?: (node: DocumentNode) => void }
+  Text?: { enter?: (node: TextNode) => void | false, leave?: (node: TextNode) => void }
+  Expression?: { enter?: (node: ExpressionNode) => void | false, leave?: (node: ExpressionNode) => void }
+  Directive?: { enter?: (node: DirectiveNode) => void | false, leave?: (node: DirectiveNode) => void }
+  Component?: { enter?: (node: ComponentNode) => void | false, leave?: (node: ComponentNode) => void }
+  Element?: { enter?: (node: ElementNode) => void | false, leave?: (node: ElementNode) => void }
+  Attribute?: { enter?: (node: AttributeNode) => void | false, leave?: (node: AttributeNode) => void }
+  Comment?: { enter?: (node: CommentNode) => void | false, leave?: (node: CommentNode) => void }
+  Script?: { enter?: (node: ScriptNode) => void | false, leave?: (node: ScriptNode) => void }
+  Style?: { enter?: (node: StyleNode) => void | false, leave?: (node: StyleNode) => void }
+}
+/**
+ * Union of all AST node types
+ */
+export type ASTNode = | DocumentNode
+  | TextNode
+  | ExpressionNode
+  | DirectiveNode
+  | ComponentNode
+  | ElementNode
+  | AttributeNode
+  | CommentNode
+  | ScriptNode
+  | StyleNode;
+/**
+ * Token types for lexer (reserved for future tokenizer implementation)
+ */
+declare type _TokenType = | 'TEXT'
+  | 'EXPRESSION_ESCAPED'
+  | 'EXPRESSION_UNESCAPED'
+  | 'DIRECTIVE_START'
+  | 'DIRECTIVE_END'
+  | 'COMMENT_HTML'
+  | 'COMMENT_STX'
+  | 'TAG_OPEN'
+  | 'TAG_CLOSE'
+  | 'TAG_SELF_CLOSE'
+  | 'EOF';
+/**
+ * Simple template parser
+ */
+export declare class TemplateParser {
+  parse(template: string, filePath?: string): DocumentNode;
+}