@ccslabs/xtend 0.1.0-rc.1

package/tools/rmt-language/format-adapter.js

@@ -0,0 +1,270 @@
+const fs = require('fs');
+const path = require('path');
+const vm = require('vm');
+const {
+  RMT_FILE_FALLBACK_CODE,
+  RMT_PARSER_REPORT_SCHEMA,
+  RMT_PARSER_SCHEMA,
+  RMT_PARSER_WORKPACKAGE,
+  createRmtParser
+} = require('./parser');
+
+const RMT_FORMAT_ADAPTER_SCHEMA = 'xtend.rmt.format-adapter.v1';
+const RMT_FORMAT_ADAPTER_MODULE_PATH = 'tools/rmt-language/format-adapter.js';
+const RMT_FORMAT_NORMALIZATION_ERROR_CODE = 'rmt.format.normalization.failed';
+const RMT_FORMAT_ADAPTER_UNAVAILABLE_CODE = 'rmt.format.adapter.unavailable';
+const RMT_CORE_ARTIFACT_PATH = 'xtendrmt/rmt-core.esm.js';
+
+function createCoreSandbox() {
+  function CustomEvent(type, init = {}) {
+    this.type = type;
+    this.detail = init.detail || null;
+    this.bubbles = init.bubbles === true;
+    this.composed = init.composed === true;
+  }
+
+  const sandbox = {
+    console,
+    setTimeout,
+    clearTimeout,
+    performance: { now: () => 0 },
+    navigator: { userAgent: 'xtend-rmt-language-tooling' },
+    CustomEvent,
+    document: {
+      addEventListener() {},
+      removeEventListener() {},
+      dispatchEvent() {
+        return true;
+      },
+      createElement(tagName) {
+        return {
+          tagName: String(tagName || '').toUpperCase(),
+          attributes: {},
+          children: [],
+          setAttribute(name, value) {
+            this.attributes[name] = String(value);
+          },
+          appendChild(child) {
+            this.children.push(child);
+            return child;
+          }
+        };
+      }
+    }
+  };
+  sandbox.globalThis = sandbox;
+  sandbox.window = sandbox;
+  sandbox.self = sandbox;
+
+  return sandbox;
+}
+
+function stripEsmExports(source) {
+  return String(source || '').replace(/\nexport\s+\{[\s\S]*?\};\s*\nexport default XtendRmtProduct;\s*$/u, '');
+}
+
+function resolveRootDir(options = {}) {
+  return options.rootDir || path.resolve(__dirname, '..', '..');
+}
+
+function loadRmtCoreFormatFactory(options = {}) {
+  const rootDir = resolveRootDir(options);
+  const artifactPath = options.coreArtifactPath
+    ? (path.isAbsolute(options.coreArtifactPath)
+      ? options.coreArtifactPath
+      : path.join(rootDir, options.coreArtifactPath))
+    : path.join(rootDir, RMT_CORE_ARTIFACT_PATH);
+  const source = fs.readFileSync(artifactPath, 'utf8');
+  const sandbox = createCoreSandbox();
+
+  vm.runInNewContext(stripEsmExports(source), sandbox, {
+    filename: RMT_CORE_ARTIFACT_PATH
+  });
+
+  const factory = sandbox.AppModules && sandbox.AppModules.createRmtFormat;
+
+  if (typeof factory !== 'function') {
+    throw new Error('XTendRMT core artifact exposes no createRmtFormat factory.');
+  }
+
+  return factory;
+}
+
+function createAdapterDiagnostic(sourceModel, input = {}) {
+  const range = input.range || (sourceModel && sourceModel.lineRange ? sourceModel.lineRange(0) : null);
+
+  return {
+    schema: 'xtend.rmt.linter.diagnostic.v1',
+    source: 'rmt-language',
+    code: input.code || RMT_FORMAT_NORMALIZATION_ERROR_CODE,
+    severity: input.severity || 'error',
+    message: input.message || input.code || 'RMT format adapter diagnostic',
+    uri: sourceModel ? sourceModel.uri : null,
+    file: sourceModel ? sourceModel.filePath : null,
+    pointer: input.pointer || null,
+    range,
+    workpackage: RMT_PARSER_WORKPACKAGE
+  };
+}
+
+function resolveRmtFormat(options = {}) {
+  if (options.rmtFormat && typeof options.rmtFormat === 'object') {
+    return {
+      ok: true,
+      rmtFormat: options.rmtFormat,
+      factorySource: 'injected-format'
+    };
+  }
+
+  try {
+    const factory = typeof options.createRmtFormat === 'function'
+      ? options.createRmtFormat
+      : loadRmtCoreFormatFactory(options);
+
+    return {
+      ok: true,
+      rmtFormat: factory(),
+      factorySource: typeof options.createRmtFormat === 'function' ? 'injected-factory' : RMT_CORE_ARTIFACT_PATH
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      rmtFormat: null,
+      error,
+      factorySource: null
+    };
+  }
+}
+
+function createRmtFormatAdapter(defaultOptions = {}) {
+  const parser = defaultOptions.parser || createRmtParser(defaultOptions);
+
+  function parseAndNormalizeSource(input = {}, options = {}) {
+    const effectiveOptions = {
+      ...defaultOptions,
+      ...options
+    };
+    const parserResult = parser.parseSource(input, effectiveOptions);
+
+    if (!parserResult.ok) {
+      return {
+        schema: RMT_FORMAT_ADAPTER_SCHEMA,
+        parserSchema: RMT_PARSER_SCHEMA,
+        reportSchema: RMT_PARSER_REPORT_SCHEMA,
+        workpackage: RMT_PARSER_WORKPACKAGE,
+        ok: false,
+        phase: 'syntax',
+        status: 'syntax_error',
+        sourceModel: parserResult.sourceModel,
+        rawDocument: null,
+        normalizedDocument: null,
+        diagnostics: parserResult.diagnostics,
+        parserResult,
+        formatDiagnostics: []
+      };
+    }
+
+    const resolvedFormat = resolveRmtFormat(effectiveOptions);
+
+    if (!resolvedFormat.ok || !resolvedFormat.rmtFormat || typeof resolvedFormat.rmtFormat.parseDocument !== 'function') {
+      const diagnostic = createAdapterDiagnostic(parserResult.sourceModel, {
+        code: RMT_FORMAT_ADAPTER_UNAVAILABLE_CODE,
+        message: resolvedFormat.error && resolvedFormat.error.message
+          ? resolvedFormat.error.message
+          : 'createRmtFormat().parseDocument ist im RMT-Core nicht verfuegbar.'
+      });
+
+      return {
+        schema: RMT_FORMAT_ADAPTER_SCHEMA,
+        parserSchema: RMT_PARSER_SCHEMA,
+        reportSchema: RMT_PARSER_REPORT_SCHEMA,
+        workpackage: RMT_PARSER_WORKPACKAGE,
+        ok: false,
+        phase: 'format',
+        status: 'format_adapter_unavailable',
+        sourceModel: parserResult.sourceModel,
+        rawDocument: parserResult.rawDocument,
+        normalizedDocument: null,
+        diagnostics: parserResult.diagnostics.concat(diagnostic),
+        parserResult,
+        formatDiagnostics: [diagnostic],
+        formatFactorySource: resolvedFormat.factorySource
+      };
+    }
+
+    try {
+      const normalizedDocument = resolvedFormat.rmtFormat.parseDocument(parserResult.sourceModel.text, {
+        sourceUrl: parserResult.sourceModel.uri,
+        filePath: parserResult.sourceModel.filePath,
+        ...effectiveOptions.formatOptions
+      });
+
+      return {
+        schema: RMT_FORMAT_ADAPTER_SCHEMA,
+        parserSchema: RMT_PARSER_SCHEMA,
+        reportSchema: RMT_PARSER_REPORT_SCHEMA,
+        workpackage: RMT_PARSER_WORKPACKAGE,
+        ok: true,
+        phase: 'normalize',
+        status: 'normalized',
+        sourceModel: parserResult.sourceModel,
+        rawDocument: parserResult.rawDocument,
+        normalizedDocument,
+        diagnostics: parserResult.diagnostics,
+        parserResult,
+        formatDiagnostics: [],
+        formatFactorySource: resolvedFormat.factorySource,
+        normalizedBy: 'createRmtFormat().parseDocument'
+      };
+    } catch (error) {
+      const diagnostic = createAdapterDiagnostic(parserResult.sourceModel, {
+        code: RMT_FORMAT_NORMALIZATION_ERROR_CODE,
+        message: error && error.message ? error.message : 'RMT format normalization failed.'
+      });
+
+      return {
+        schema: RMT_FORMAT_ADAPTER_SCHEMA,
+        parserSchema: RMT_PARSER_SCHEMA,
+        reportSchema: RMT_PARSER_REPORT_SCHEMA,
+        workpackage: RMT_PARSER_WORKPACKAGE,
+        ok: false,
+        phase: 'format',
+        status: 'normalization_error',
+        sourceModel: parserResult.sourceModel,
+        rawDocument: parserResult.rawDocument,
+        normalizedDocument: null,
+        diagnostics: parserResult.diagnostics.concat(diagnostic),
+        parserResult,
+        formatDiagnostics: [diagnostic],
+        formatFactorySource: resolvedFormat.factorySource
+      };
+    }
+  }
+
+  return Object.freeze({
+    schema: RMT_FORMAT_ADAPTER_SCHEMA,
+    parserSchema: RMT_PARSER_SCHEMA,
+    workpackage: RMT_PARSER_WORKPACKAGE,
+    parseAndNormalizeSource
+  });
+}
+
+function parseAndNormalizeRmtSource(input = {}, options = {}) {
+  return createRmtFormatAdapter(options).parseAndNormalizeSource(input, options);
+}
+
+module.exports = {
+  RMT_CORE_ARTIFACT_PATH,
+  RMT_FILE_FALLBACK_CODE,
+  RMT_FORMAT_ADAPTER_MODULE_PATH,
+  RMT_FORMAT_ADAPTER_SCHEMA,
+  RMT_FORMAT_ADAPTER_UNAVAILABLE_CODE,
+  RMT_FORMAT_NORMALIZATION_ERROR_CODE,
+  RMT_PARSER_REPORT_SCHEMA,
+  RMT_PARSER_SCHEMA,
+  RMT_PARSER_WORKPACKAGE,
+  createRmtFormatAdapter,
+  loadRmtCoreFormatFactory,
+  parseAndNormalizeRmtSource,
+  stripEsmExports
+};

package/tools/rmt-language/hover.d.ts

@@ -0,0 +1,12 @@
+export * from './rmt-tooling-public-types';
+import type { RmtHover, RmtToolingConstant, RmtToolingFactory, RmtToolingFunction } from './rmt-tooling-public-types';
+
+export declare const createRmtHoverProvider: RmtToolingFactory;
+export declare const getRmtHover: RmtToolingFunction<RmtHover | null>;
+export declare const RMT_HOVER_MODULE_PATH: RmtToolingConstant;
+export declare const RMT_HOVER_PACKAGE_SCRIPT: RmtToolingConstant;
+export declare const RMT_HOVER_PROVIDER_SCHEMA: RmtToolingConstant;
+export declare const RMT_HOVER_REPORT_SCHEMA: RmtToolingConstant;
+export declare const RMT_HOVER_SCHEMA: RmtToolingConstant;
+export declare const RMT_HOVER_SUITE_PATH: RmtToolingConstant;
+export declare const RMT_HOVER_WORKPACKAGE: RmtToolingConstant;

package/tools/rmt-language/hover.js

@@ -0,0 +1,326 @@
+const {
+  buildSemanticGraph
+} = require('./semantic-graph');
+const {
+  BUILT_IN_ADAPTER_IDS,
+  DOMAIN_FIELD_COMPLETIONS,
+  HYDRATION_POLICIES,
+  SCHEDULE_LANES,
+  TEMPLATE_MODES,
+  TOP_LEVEL_DOMAINS,
+  loadComponentManifest
+} = require('./completions');
+const {
+  createDefinitionTarget
+} = require('./definitions');
+
+const RMT_HOVER_PROVIDER_SCHEMA = 'xtend.rmt.hover-provider.v1';
+const RMT_HOVER_REPORT_SCHEMA = 'xtend.rmt.hover-report.v1';
+const RMT_HOVER_SCHEMA = 'xtend.rmt.hover.v1';
+const RMT_HOVER_WORKPACKAGE = 'WP-E14-08';
+const RMT_HOVER_MODULE_PATH = 'tools/rmt-language/hover.js';
+const RMT_HOVER_SUITE_PATH = 'tests/rmt-language/rmt_navigation_suite.js';
+const RMT_HOVER_PACKAGE_SCRIPT = 'npm run test:rmt-navigation';
+
+function normalizeString(value) {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function decodePointerSegment(segment) {
+  return segment.replace(/~1/g, '/').replace(/~0/g, '~');
+}
+
+function parsePointer(pointer) {
+  const safePointer = normalizeString(pointer);
+
+  if (!safePointer || safePointer === '/') {
+    return [];
+  }
+
+  if (!safePointer.startsWith('/')) {
+    return null;
+  }
+
+  return safePointer.slice(1).split('/').map(decodePointerSegment);
+}
+
+function getPointerValue(document, pointer) {
+  const segments = parsePointer(pointer);
+
+  if (!segments) {
+    return undefined;
+  }
+
+  let node = document;
+
+  for (const segment of segments) {
+    if (node === null || node === undefined) {
+      return undefined;
+    }
+
+    if (Array.isArray(node)) {
+      if (!/^(0|[1-9]\d*)$/.test(segment)) {
+        return undefined;
+      }
+      node = node[Number(segment)];
+      continue;
+    }
+
+    if (typeof node === 'object') {
+      node = node[segment];
+      continue;
+    }
+
+    return undefined;
+  }
+
+  return node;
+}
+
+function rangeForPointer(graph, pointer, target = 'value') {
+  const sourceModel = graph && graph.sourceModel;
+
+  if (!sourceModel || typeof sourceModel.findJsonPointerRange !== 'function') {
+    return null;
+  }
+
+  const pointerRange = sourceModel.findJsonPointerRange(pointer, { target });
+
+  return pointerRange ? pointerRange.range : null;
+}
+
+function lookupEntry(entries, label) {
+  const safeLabel = normalizeString(label);
+  const match = entries.find((entry) => Array.isArray(entry) && entry[0] === safeLabel);
+
+  return match ? {
+    label: match[0],
+    documentation: match[1] || ''
+  } : null;
+}
+
+function createHover(input = {}) {
+  const title = input.title || input.kind || 'RMT';
+  const lines = [title, input.documentation || '', input.detail || ''].filter(Boolean);
+
+  return {
+    schema: RMT_HOVER_SCHEMA,
+    kind: input.kind || 'value',
+    title,
+    markdown: lines.join('\n\n'),
+    contents: lines,
+    pointer: input.pointer || null,
+    range: input.range || null,
+    target: input.target || null,
+    source: input.source || 'rmt-hover-provider'
+  };
+}
+
+function buildGraph(input = {}, options = {}) {
+  return options.graph || buildSemanticGraph(input, options);
+}
+
+function createReferenceHover(graph, pointer, reference) {
+  const target = graph.getDefinitionForReference(reference);
+  const staticAdapter = reference.targetDomain === 'adapters'
+    ? lookupEntry(BUILT_IN_ADAPTER_IDS, reference.targetId)
+    : null;
+  const documentation = [
+    `${reference.relationship} reference to ${reference.targetDomain} "${reference.targetId}".`,
+    staticAdapter ? staticAdapter.documentation : '',
+    reference.resolved ? `Definition: ${reference.targetPointer}` : 'Reference is unresolved.'
+  ].filter(Boolean).join('\n');
+
+  return createHover({
+    kind: 'reference',
+    title: `${reference.targetDomain}: ${reference.targetId}`,
+    documentation,
+    pointer,
+    range: reference.sourceRange || rangeForPointer(graph, pointer),
+    target: target ? createDefinitionTarget({
+      entry: target,
+      reference
+    }) : null,
+    source: 'semantic-graph.reference'
+  });
+}
+
+function createStaticHover(graph, pointer, kind, value, catalogEntry, source) {
+  return createHover({
+    kind,
+    title: value,
+    documentation: catalogEntry.documentation,
+    pointer,
+    range: rangeForPointer(graph, pointer),
+    source
+  });
+}
+
+function createComponentTagHover(graph, pointer, value, options = {}) {
+  const manifest = loadComponentManifest(options);
+  const modulePath = manifest[value] || null;
+  const documentation = modulePath
+    ? `XTend Component Tag. Manifest module: ${modulePath}`
+    : 'XTend Component Tag from the active RMT document.';
+
+  return createHover({
+    kind: 'component-tag',
+    title: value,
+    documentation,
+    pointer,
+    range: rangeForPointer(graph, pointer),
+    source: modulePath ? 'components/manifest.json' : 'semantic-graph.catalogHints'
+  });
+}
+
+function createTopLevelHover(graph, pointer, domain) {
+  const entry = lookupEntry(TOP_LEVEL_DOMAINS, domain);
+
+  if (!entry) {
+    return null;
+  }
+
+  return createHover({
+    kind: 'domain',
+    title: domain,
+    documentation: entry.documentation,
+    pointer,
+    range: rangeForPointer(graph, pointer, 'key') || rangeForPointer(graph, pointer),
+    source: 'rmt-domain-catalog'
+  });
+}
+
+function createFieldHover(graph, pointer, field) {
+  const domain = (parsePointer(pointer) || [])[0] || '';
+  const fieldCatalog = DOMAIN_FIELD_COMPLETIONS[domain] || [];
+
+  if (!fieldCatalog.includes(field)) {
+    return null;
+  }
+
+  return createHover({
+    kind: 'field',
+    title: field,
+    documentation: `RMT ${domain} field.`,
+    pointer,
+    range: rangeForPointer(graph, pointer, 'key') || rangeForPointer(graph, pointer),
+    source: 'rmt-domain-field-catalog'
+  });
+}
+
+function inferStaticHover(graph, pointer, options = {}) {
+  const segments = parsePointer(pointer) || [];
+  const field = segments[segments.length - 1] || '';
+  const value = getPointerValue(graph.sourceDocument, pointer);
+  const stringValue = normalizeString(value);
+
+  if (!stringValue) {
+    return null;
+  }
+
+  if (field === 'tag') {
+    return createComponentTagHover(graph, pointer, stringValue, options);
+  }
+
+  if (field === 'lane') {
+    const entry = lookupEntry(SCHEDULE_LANES, stringValue);
+    return entry ? createStaticHover(graph, pointer, 'lane', stringValue, entry, 'rmt-lane-catalog') : null;
+  }
+
+  if (field === 'mode' && pointer.includes('/hydration/')) {
+    const entry = lookupEntry(HYDRATION_POLICIES, stringValue);
+    return entry ? createStaticHover(graph, pointer, 'hydration-policy', stringValue, entry, 'rmt-hydration-policy-catalog') : null;
+  }
+
+  if (field === 'mode' && pointer.startsWith('/templates/')) {
+    const entry = lookupEntry(TEMPLATE_MODES, stringValue);
+    return entry ? createStaticHover(graph, pointer, 'template-mode', stringValue, entry, 'rmt-template-mode-catalog') : null;
+  }
+
+  return null;
+}
+
+function getRmtHover(input = {}, options = {}) {
+  const graph = buildGraph(input, options);
+  const pointer = normalizeString(options.pointer || input.pointer);
+
+  if (!pointer) {
+    return {
+      schema: RMT_HOVER_REPORT_SCHEMA,
+      providerSchema: RMT_HOVER_PROVIDER_SCHEMA,
+      hoverSchema: RMT_HOVER_SCHEMA,
+      workpackage: RMT_HOVER_WORKPACKAGE,
+      status: 'not_found',
+      ok: false,
+      pointer,
+      hover: null,
+      graphStatus: graph ? graph.status : null
+    };
+  }
+
+  if (!graph || graph.status === 'source_unavailable') {
+    return {
+      schema: RMT_HOVER_REPORT_SCHEMA,
+      providerSchema: RMT_HOVER_PROVIDER_SCHEMA,
+      hoverSchema: RMT_HOVER_SCHEMA,
+      workpackage: RMT_HOVER_WORKPACKAGE,
+      status: 'source_unavailable',
+      ok: false,
+      pointer,
+      hover: null,
+      graphStatus: graph ? graph.status : null
+    };
+  }
+
+  const segments = parsePointer(pointer) || [];
+  const field = segments[segments.length - 1] || '';
+  const reference = graph.findReferenceAtPointer(pointer);
+  const hover = reference
+    ? createReferenceHover(graph, pointer, reference)
+    : inferStaticHover(graph, pointer, options)
+      || (segments.length === 1 ? createTopLevelHover(graph, pointer, segments[0]) : null)
+      || createFieldHover(graph, pointer, field);
+
+  return {
+    schema: RMT_HOVER_REPORT_SCHEMA,
+    providerSchema: RMT_HOVER_PROVIDER_SCHEMA,
+    hoverSchema: RMT_HOVER_SCHEMA,
+    workpackage: RMT_HOVER_WORKPACKAGE,
+    status: hover ? 'found' : 'not_found',
+    ok: !!hover,
+    pointer,
+    hover,
+    graphStatus: graph.status,
+    manifestHints: graph.manifestHints || {},
+    catalogHints: graph.catalogHints || {}
+  };
+}
+
+function createRmtHoverProvider(defaultOptions = {}) {
+  function hover(input = {}, options = {}) {
+    return getRmtHover(input, {
+      ...defaultOptions,
+      ...options
+    });
+  }
+
+  return Object.freeze({
+    schema: RMT_HOVER_PROVIDER_SCHEMA,
+    reportSchema: RMT_HOVER_REPORT_SCHEMA,
+    hoverSchema: RMT_HOVER_SCHEMA,
+    workpackage: RMT_HOVER_WORKPACKAGE,
+    hover
+  });
+}
+
+module.exports = {
+  RMT_HOVER_MODULE_PATH,
+  RMT_HOVER_PACKAGE_SCRIPT,
+  RMT_HOVER_PROVIDER_SCHEMA,
+  RMT_HOVER_REPORT_SCHEMA,
+  RMT_HOVER_SCHEMA,
+  RMT_HOVER_SUITE_PATH,
+  RMT_HOVER_WORKPACKAGE,
+  createRmtHoverProvider,
+  getRmtHover
+};