npm - @unrdf/kgn - Versions diffs - 5.0.1 - Mend

@unrdf/kgn 5.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (68) hide show

package/LICENSE +21 -0
package/README.md +210 -0
package/package.json +90 -0
package/src/MIGRATION_COMPLETE.md +186 -0
package/src/PORT-MAP.md +302 -0
package/src/base/filter-templates.js +479 -0
package/src/base/index.js +92 -0
package/src/base/injection-targets.js +583 -0
package/src/base/macro-templates.js +298 -0
package/src/base/macro-templates.js.bak +461 -0
package/src/base/shacl-templates.js +617 -0
package/src/base/template-base.js +388 -0
package/src/core/attestor.js +381 -0
package/src/core/filters.js +518 -0
package/src/core/index.js +21 -0
package/src/core/kgen-engine.js +372 -0
package/src/core/parser.js +447 -0
package/src/core/post-processor.js +313 -0
package/src/core/renderer.js +469 -0
package/src/doc-generator/cli.mjs +122 -0
package/src/doc-generator/index.mjs +28 -0
package/src/doc-generator/mdx-generator.mjs +71 -0
package/src/doc-generator/nav-generator.mjs +136 -0
package/src/doc-generator/parser.mjs +291 -0
package/src/doc-generator/rdf-builder.mjs +306 -0
package/src/doc-generator/scanner.mjs +189 -0
package/src/engine/index.js +42 -0
package/src/engine/pipeline.js +448 -0
package/src/engine/renderer.js +604 -0
package/src/engine/template-engine.js +566 -0
package/src/filters/array.js +436 -0
package/src/filters/data.js +479 -0
package/src/filters/index.js +270 -0
package/src/filters/rdf.js +264 -0
package/src/filters/text.js +369 -0
package/src/index.js +109 -0
package/src/inheritance/index.js +40 -0
package/src/injection/api.js +260 -0
package/src/injection/atomic-writer.js +327 -0
package/src/injection/constants.js +136 -0
package/src/injection/idempotency-manager.js +295 -0
package/src/injection/index.js +28 -0
package/src/injection/injection-engine.js +378 -0
package/src/injection/integration.js +339 -0
package/src/injection/modes/index.js +341 -0
package/src/injection/rollback-manager.js +373 -0
package/src/injection/target-resolver.js +323 -0
package/src/injection/tests/atomic-writer.test.js +382 -0
package/src/injection/tests/injection-engine.test.js +611 -0
package/src/injection/tests/integration.test.js +392 -0
package/src/injection/tests/run-tests.js +283 -0
package/src/injection/validation-engine.js +547 -0
package/src/linter/determinism-linter.js +473 -0
package/src/linter/determinism.js +410 -0
package/src/linter/index.js +6 -0
package/src/linter/test-doubles.js +475 -0
package/src/parser/frontmatter.js +228 -0
package/src/parser/variables.js +344 -0
package/src/renderer/deterministic.js +245 -0
package/src/renderer/index.js +6 -0
package/src/templates/latex/academic-paper.njk +186 -0
package/src/templates/latex/index.js +104 -0
package/src/templates/nextjs/app-page.njk +66 -0
package/src/templates/nextjs/index.js +80 -0
package/src/templates/office/docx/document.njk +368 -0
package/src/templates/office/index.js +79 -0
package/src/templates/office/word-report.njk +129 -0
package/src/utils/template-utils.js +426 -0

package/src/base/template-base.js ADDED Viewed

@@ -0,0 +1,388 @@
+/**
+ * KGEN Template Base Class - Foundation for all template types
+ *
+ * Provides core functionality for template inheritance, composition, and validation
+ * All template generators should extend this base class for consistency
+ */
+import crypto from 'crypto';
+import { KGenTemplateEngine } from '../core/kgen-engine.js';
+import { TemplateInheritanceEngine } from '../inheritance/index.js';
+export class KGenTemplateBase {
+  constructor(options = {}) {
+    this.options = {
+      strictMode: options.strictMode !== false,
+      deterministicMode: options.deterministicMode !== false,
+      staticBuildTime: options.staticBuildTime || '2024-01-01T00:00:00.000Z',
+      enableInheritance: options.enableInheritance !== false,
+      enableValidation: options.enableValidation !== false,
+      templateDir: options.templateDir || './templates',
+      ...options
+    };
+    // Core engines
+    this.engine = new KGenTemplateEngine(this.options);
+    this.inheritanceEngine = new TemplateInheritanceEngine(this.options);
+    // Template metadata
+    this.metadata = {
+      name: options.name || this.constructor.name,
+      version: options.version || '1.0.0',
+      description: options.description || 'KGEN Template',
+      author: options.author || 'KGEN Generator',
+      created: this.options.staticBuildTime,
+      modified: this.options.staticBuildTime,
+      namespace: options.namespace || 'kgen',
+      category: options.category || 'base',
+      tags: options.tags || [],
+      dependencies: options.dependencies || [],
+      extends: options.extends || null
+    };
+    // Template registry for inheritance
+    this.templates = new Map();
+    this.blocks = new Map();
+    this.macros = new Map();
+    // Validation rules
+    this.validationRules = new Map();
+    // Initialize base templates
+    this.initializeBaseTemplates();
+  }
+  /**
+   * Initialize base templates and blocks
+   */
+  initializeBaseTemplates() {
+    // Base layout template
+    this.registerTemplate('base.layout', `{%- block doctype -%}
+<!DOCTYPE html>
+{%- endblock -%}
+{%- block html_attrs -%}
+<html lang="{{ lang | default('en') }}">
+{%- endblock -%}
+{%- block head -%}
+<head>
+  {%- block meta -%}
+  <meta charset="{{ charset | default('UTF-8') }}">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  {%- endblock -%}
+  {%- block title -%}
+  <title>{{ title | default('KGEN Generated') }}</title>
+  {%- endblock -%}
+  {%- block styles -%}
+  {%- endblock -%}
+</head>
+{%- endblock -%}
+{%- block body -%}
+<body>
+  {%- block content -%}
+  <!-- Content goes here -->
+  {%- endblock -%}
+  {%- block scripts -%}
+  {%- endblock -%}
+</body>
+{%- endblock -%}
+</html>`);
+    // Base component template
+    this.registerTemplate('base.component', `{%- set componentName = name | default('Component') -%}
+{%- set componentId = componentName | lower | replace(' ', '-') -%}
+{%- block wrapper -%}
+<div id="{{ componentId }}" class="{{ cssClass | default('kgen-component') }}">
+  {%- block header -%}
+  {%- if title -%}
+  <header class="component-header">
+    <h3>{{ title }}</h3>
+  </header>
+  {%- endif -%}
+  {%- endblock -%}
+  {%- block content -%}
+  <div class="component-content">
+    {{ content | default('<!-- Component content -->') }}
+  </div>
+  {%- endblock -%}
+  {%- block footer -%}
+  {%- if showFooter -%}
+  <footer class="component-footer">
+    {{ footerContent | default('') }}
+  </footer>
+  {%- endif -%}
+  {%- endblock -%}
+</div>
+{%- endblock -%}`);
+    // Base module template
+    this.registerTemplate('base.module', `{%- set moduleName = name | default('Module') -%}
+/**
+ * {{ moduleName }} - Generated by KGEN
+ *
+ * {%- if description %}
+ * {{ description }}
+ * {%- endif %}
+ *
+ * @generated {{ __kgen.renderTime }}
+ */
+{%- block imports -%}
+{%- for import in imports | default([]) %}
+import {{ import.name }}{{ import.from ? ' from ' + import.from : '' }};
+{%- endfor -%}
+{%- endblock -%}
+{%- block constants -%}
+{%- for constant in constants | default([]) %}
+const {{ constant.name }} = {{ constant.value | json }};
+{%- endfor -%}
+{%- endblock -%}
+{%- block main -%}
+export class {{ moduleName }} {
+  constructor(options = {}) {
+    this.options = { ...options };
+  }
+  {%- block methods -%}
+  {%- for method in methods | default([]) %}
+  {{ method.name }}({{ method.params | default('') }}) {
+    {{ method.body | default('// Method implementation') }}
+  }
+  {%- endfor -%}
+  {%- endblock -%}
+}
+{%- endblock -%}
+{%- block exports -%}
+export default {{ moduleName }};
+{%- endblock -%}`);
+    // Register base macros
+    this.registerMacro('kgen_header', `{%- macro kgen_header(title, level=1) -%}
+<h{{ level }}>{{ title }}</h{{ level }}>
+{%- endmacro -%}`);
+    this.registerMacro('kgen_timestamp', `{%- macro kgen_timestamp(format='iso') -%}
+{%- if format == 'iso' -%}
+{{ __kgen.renderTime }}
+{%- else -%}
+{{ __kgen.renderTime | formatDate(format) }}
+{%- endif -%}
+{%- endmacro -%}`);
+    this.registerMacro('kgen_hash', `{%- macro kgen_hash(content) -%}
+{{ content | hash | shortHash(8) }}
+{%- endmacro -%}`);
+  }
+  /**
+   * Register a template with the base class
+   */
+  registerTemplate(name, content, metadata = {}) {
+    this.templates.set(name, {
+      content,
+      metadata: {
+        name,
+        registered: this.options.staticBuildTime,
+        ...metadata
+      }
+    });
+  }
+  /**
+   * Register a block for inheritance
+   */
+  registerBlock(name, content, metadata = {}) {
+    this.blocks.set(name, {
+      content,
+      metadata: {
+        name,
+        registered: this.options.staticBuildTime,
+        ...metadata
+      }
+    });
+  }
+  /**
+   * Register a macro for reuse
+   */
+  registerMacro(name, content, metadata = {}) {
+    this.macros.set(name, {
+      content,
+      metadata: {
+        name,
+        registered: this.options.staticBuildTime,
+        ...metadata
+      }
+    });
+  }
+  /**
+   * Register validation rule
+   */
+  registerValidationRule(name, rule) {
+    this.validationRules.set(name, rule);
+  }
+  /**
+   * Generate template from registered template
+   */
+  async generateFromTemplate(templateName, context = {}, options = {}) {
+    if (!this.templates.has(templateName)) {
+      throw new Error(`Template '${templateName}' not found`);
+    }
+    const template = this.templates.get(templateName);
+    const mergedContext = {
+      ...context,
+      __template: {
+        name: templateName,
+        metadata: template.metadata
+      }
+    };
+    return await this.engine.execute(template.content, mergedContext);
+  }
+  /**
+   * Generate with inheritance processing
+   */
+  async generateWithInheritance(templatePath, context = {}, options = {}) {
+    if (!this.options.enableInheritance) {
+      return await this.engine.execute(templatePath, context);
+    }
+    const result = await this.inheritanceEngine.processTemplate(templatePath, context, options);
+    if (!result.compiled || !result.compiled.content) {
+      throw new Error(`Failed to process inheritance for ${templatePath}`);
+    }
+    return {
+      success: true,
+      content: result.compiled.content,
+      metadata: result.metadata,
+      dependencies: result.dependencies,
+      hash: result.hash
+    };
+  }
+  /**
+   * Validate generated content
+   */
+  async validateContent(content, rules = []) {
+    if (!this.options.enableValidation) {
+      return { valid: true, errors: [] };
+    }
+    const errors = [];
+    const rulesToApply = rules.length > 0 ? rules : Array.from(this.validationRules.keys());
+    for (const ruleName of rulesToApply) {
+      const rule = this.validationRules.get(ruleName);
+      if (rule) {
+        try {
+          const result = await rule(content);
+          if (!result.valid) {
+            errors.push({
+              rule: ruleName,
+              message: result.message,
+              line: result.line,
+              column: result.column
+            });
+          }
+        } catch (error) {
+          errors.push({
+            rule: ruleName,
+            message: `Validation rule failed: ${error.message}`
+          });
+        }
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors,
+      rulesApplied: rulesToApply.length
+    };
+  }
+  /**
+   * Get template metadata
+   */
+  getMetadata() {
+    return {
+      ...this.metadata,
+      templates: Array.from(this.templates.keys()),
+      blocks: Array.from(this.blocks.keys()),
+      macros: Array.from(this.macros.keys()),
+      validationRules: Array.from(this.validationRules.keys())
+    };
+  }
+  /**
+   * Generate deterministic hash for template
+   */
+  generateTemplateHash(content, context = {}) {
+    const hashData = {
+      content,
+      context: Object.keys(context).sort(),
+      metadata: this.metadata,
+      templates: Array.from(this.templates.keys()).sort(),
+      timestamp: this.options.staticBuildTime
+    };
+    return crypto.createHash('sha256')
+      .update(JSON.stringify(hashData), 'utf8')
+      .digest('hex');
+  }
+  /**
+   * Clone template base with new options
+   */
+  clone(newOptions = {}) {
+    const cloned = new this.constructor({
+      ...this.options,
+      ...newOptions
+    });
+    // Copy registered templates
+    for (const [name, template] of this.templates) {
+      cloned.templates.set(name, { ...template });
+    }
+    for (const [name, block] of this.blocks) {
+      cloned.blocks.set(name, { ...block });
+    }
+    for (const [name, macro] of this.macros) {
+      cloned.macros.set(name, { ...macro });
+    }
+    for (const [name, rule] of this.validationRules) {
+      cloned.validationRules.set(name, rule);
+    }
+    return cloned;
+  }
+  /**
+   * Get template statistics
+   */
+  getStats() {
+    return {
+      templates: this.templates.size,
+      blocks: this.blocks.size,
+      macros: this.macros.size,
+      validationRules: this.validationRules.size,
+      options: this.options,
+      metadata: this.metadata
+    };
+  }
+}
+export default KGenTemplateBase;