@ccslabs/xtend 0.1.0-rc.1

package/tools/rmt-language/parser.js

@@ -0,0 +1,111 @@
+const {
+  RMT_SOURCE_MODEL_WORKPACKAGE,
+  createRmtSourceModel
+} = require('./source-model');
+
+const RMT_PARSER_SCHEMA = 'xtend.rmt.parser.v1';
+const RMT_PARSER_REPORT_SCHEMA = 'xtend.rmt.parser-report.v1';
+const RMT_PARSER_WORKPACKAGE = 'WP-E14-03';
+const RMT_PARSER_MODULE_PATH = 'tools/rmt-language/parser.js';
+const RMT_PARSER_SUITE_PATH = 'tests/rmt-language/rmt_parser_suite.js';
+const RMT_PARSER_PACKAGE_SCRIPT = 'npm run test:rmt-parser';
+const RMT_FILE_FALLBACK_CODE = 'rmt.document.extension.fallback-used';
+
+function normalizeSourceInput(input = {}, options = {}) {
+  if (typeof input === 'string') {
+    return {
+      text: input,
+      uri: options.uri,
+      filePath: options.filePath,
+      version: options.version
+    };
+  }
+
+  return {
+    text: String(input.text || ''),
+    uri: input.uri || options.uri,
+    filePath: input.filePath || options.filePath,
+    version: input.version === undefined ? options.version : input.version,
+    languageId: input.languageId || options.languageId
+  };
+}
+
+function createFilePolicyDiagnostics(sourceModel) {
+  if (!sourceModel || !sourceModel.filePolicy || !sourceModel.filePolicy.fallback) {
+    return [];
+  }
+
+  return [
+    sourceModel.createDiagnostic({
+      code: RMT_FILE_FALLBACK_CODE,
+      severity: 'warning',
+      message: `${sourceModel.filePolicy.extension} ist nur ein RMT-Fallback-Dateityp. Neue Dokumente sollen .rmt verwenden.`,
+      range: sourceModel.lineRange(0),
+      workpackage: RMT_PARSER_WORKPACKAGE
+    })
+  ];
+}
+
+function createRmtParser(defaultOptions = {}) {
+  function parseSource(input = {}, options = {}) {
+    const normalizedInput = normalizeSourceInput(input, {
+      ...defaultOptions,
+      ...options
+    });
+    const sourceModel = createRmtSourceModel(normalizedInput);
+    const filePolicyDiagnostics = createFilePolicyDiagnostics(sourceModel);
+    const parsed = sourceModel.parseJson();
+
+    if (!parsed.ok) {
+      return {
+        schema: RMT_PARSER_SCHEMA,
+        workpackage: RMT_PARSER_WORKPACKAGE,
+        ok: false,
+        phase: 'syntax',
+        status: 'syntax_error',
+        sourceModel,
+        rawDocument: null,
+        diagnostics: filePolicyDiagnostics.concat(parsed.diagnostics),
+        syntaxDiagnostics: parsed.diagnostics,
+        filePolicyDiagnostics
+      };
+    }
+
+    return {
+      schema: RMT_PARSER_SCHEMA,
+      workpackage: RMT_PARSER_WORKPACKAGE,
+      ok: true,
+      phase: 'parse',
+      status: 'parsed',
+      sourceModel,
+      rawDocument: parsed.value,
+      diagnostics: filePolicyDiagnostics,
+      syntaxDiagnostics: [],
+      filePolicyDiagnostics
+    };
+  }
+
+  return Object.freeze({
+    schema: RMT_PARSER_SCHEMA,
+    workpackage: RMT_PARSER_WORKPACKAGE,
+    parseSource
+  });
+}
+
+function parseRmtSource(input = {}, options = {}) {
+  return createRmtParser(options).parseSource(input, options);
+}
+
+module.exports = {
+  RMT_FILE_FALLBACK_CODE,
+  RMT_PARSER_MODULE_PATH,
+  RMT_PARSER_PACKAGE_SCRIPT,
+  RMT_PARSER_REPORT_SCHEMA,
+  RMT_PARSER_SCHEMA,
+  RMT_PARSER_SUITE_PATH,
+  RMT_PARSER_WORKPACKAGE,
+  RMT_SOURCE_MODEL_WORKPACKAGE,
+  createFilePolicyDiagnostics,
+  createRmtParser,
+  parseRmtSource
+};

package/tools/rmt-language/rmt-tooling-public-types.d.ts

@@ -0,0 +1,179 @@
+export type RmtJsonPrimitive = string | number | boolean | null;
+export type RmtJsonValue = RmtJsonPrimitive | RmtJsonValue[] | { [key: string]: RmtJsonValue };
+export type RmtDiagnosticSeverity = 'error' | 'warning' | 'info' | 'hint';
+export type RmtDiagnosticSource = 'rmt' | 'rmt-vnext' | 'rmt-language' | 'rmt-linter' | 'rmt-language-server' | string;
+
+export interface RmtPosition {
+  line: number;
+  character: number;
+  offset?: number;
+}
+
+export interface RmtRange {
+  start: RmtPosition;
+  end: RmtPosition;
+}
+
+export interface RmtTextDocument {
+  uri?: string;
+  filePath?: string;
+  languageId?: string;
+  version?: number;
+  text: string;
+}
+
+export interface RmtSourceRef {
+  uri?: string;
+  filePath?: string;
+  pointer?: string;
+  range?: RmtRange;
+}
+
+export interface RmtToolingDiagnostic {
+  code: string;
+  message: string;
+  severity?: RmtDiagnosticSeverity;
+  source?: RmtDiagnosticSource;
+  range?: RmtRange;
+  pointer?: string;
+  sourceRef?: RmtSourceRef;
+  data?: RmtJsonValue;
+}
+
+export interface RmtTextEdit {
+  range: RmtRange;
+  newText: string;
+}
+
+export interface RmtWorkspaceEdit {
+  changes?: Record<string, RmtTextEdit[]>;
+  documentChanges?: Array<{
+    textDocument?: { uri: string; version?: number | null };
+    edits: RmtTextEdit[];
+  }>;
+}
+
+export interface RmtCompletionItem {
+  label: string;
+  kind?: string | number;
+  detail?: string;
+  documentation?: string | RmtMarkupContent;
+  insertText?: string;
+  sortText?: string;
+  filterText?: string;
+  data?: RmtJsonValue;
+}
+
+export interface RmtHover {
+  contents: string | RmtMarkupContent | Array<string | RmtMarkupContent>;
+  range?: RmtRange;
+}
+
+export interface RmtDocumentSymbol {
+  name: string;
+  kind: string | number;
+  range: RmtRange;
+  selectionRange?: RmtRange;
+  detail?: string;
+  children?: RmtDocumentSymbol[];
+}
+
+export interface RmtDefinitionTarget {
+  uri?: string;
+  range: RmtRange;
+  selectionRange?: RmtRange;
+  pointer?: string;
+}
+
+export interface RmtCodeAction {
+  title: string;
+  kind?: string;
+  diagnostics?: RmtToolingDiagnostic[];
+  edit?: RmtWorkspaceEdit;
+  command?: RmtCommand;
+  isPreferred?: boolean;
+  data?: RmtJsonValue;
+}
+
+export interface RmtCommand {
+  title: string;
+  command: string;
+  arguments?: RmtJsonValue[];
+}
+
+export interface RmtMarkupContent {
+  kind: 'plaintext' | 'markdown' | string;
+  value: string;
+}
+
+export interface RmtParseResult<TAst = RmtJsonValue> {
+  ok: boolean;
+  ast?: TAst;
+  document?: TAst;
+  diagnostics: RmtToolingDiagnostic[];
+  sourceMap?: Record<string, RmtSourceRef>;
+}
+
+export interface RmtCompileResult<TCore = RmtJsonValue> {
+  ok: boolean;
+  core?: TCore;
+  output?: TCore;
+  diagnostics: RmtToolingDiagnostic[];
+  sourceMap?: Record<string, RmtSourceRef>;
+}
+
+export interface RmtLanguageServiceReport<TData = RmtJsonValue> {
+  schema?: string;
+  ok: boolean;
+  diagnostics: RmtToolingDiagnostic[];
+  warnings?: RmtToolingDiagnostic[];
+  data?: TData;
+}
+
+export interface RmtToolingReport<TData = RmtJsonValue> extends RmtLanguageServiceReport<TData> {
+  workpackage?: string;
+  status?: string;
+  targetReadiness?: string;
+  reportSchema?: string;
+}
+
+export interface RmtToolingOptions {
+  rootDir?: string;
+  cwd?: string;
+  uri?: string;
+  filePath?: string;
+  source?: string;
+  text?: string;
+  document?: RmtTextDocument;
+  [key: string]: unknown;
+}
+
+export type RmtToolingArguments = unknown[];
+export type RmtToolingFunction<TReturn = RmtToolingReport> = (...args: RmtToolingArguments) => TReturn;
+export type RmtToolingFactory<TReturn = RmtToolingReport> = (...args: RmtToolingArguments) => TReturn;
+export type RmtToolingClassConstructor<TInstance = RmtToolingReport> = new (...args: RmtToolingArguments) => TInstance;
+export type RmtToolingConstant<TValue = string> = TValue;
+
+export interface RmtLanguageServiceProvider {
+  analyze?(document: RmtTextDocument | string, options?: RmtToolingOptions): RmtLanguageServiceReport;
+  lint?(document: RmtTextDocument | string, options?: RmtToolingOptions): RmtToolingDiagnostic[] | RmtLanguageServiceReport;
+  format?(document: RmtTextDocument | string, options?: RmtToolingOptions): string | RmtTextEdit[];
+  completions?(document: RmtTextDocument | string, position?: RmtPosition, options?: RmtToolingOptions): RmtCompletionItem[];
+  hover?(document: RmtTextDocument | string, position?: RmtPosition, options?: RmtToolingOptions): RmtHover | null;
+  symbols?(document: RmtTextDocument | string, options?: RmtToolingOptions): RmtDocumentSymbol[];
+  definition?(document: RmtTextDocument | string, position?: RmtPosition, options?: RmtToolingOptions): RmtDefinitionTarget | null;
+  codeActions?(document: RmtTextDocument | string, range?: RmtRange, options?: RmtToolingOptions): RmtCodeAction[];
+}
+
+export interface RmtJsonRpcMessage {
+  jsonrpc: '2.0';
+  id?: string | number | null;
+  method?: string;
+  params?: RmtJsonValue;
+  result?: RmtJsonValue;
+  error?: {
+    code: number;
+    message: string;
+    data?: RmtJsonValue;
+  };
+}

package/tools/rmt-language/rules/boundary-policy.js

@@ -0,0 +1,81 @@
+const BOUNDARY_FIELD_NAMES = new Set([
+  'componentModule',
+  'componentImport',
+  'customElementImport',
+  'module',
+  'runtimeImport',
+  'xtendImport'
+]);
+
+const DEPRECATED_FIELDS = new Map([
+  ['cdn', 'Lokale ESM-Module oder Manifest-Records statt CDN-Felder nutzen.'],
+  ['cdnUrl', 'Lokale ESM-Module oder Manifest-Records statt CDN-Felder nutzen.'],
+  ['rmtJsonFallback', 'Native .rmt Dateien statt .rmt.json Authoring nutzen.'],
+  ['legacyTemplate', 'Aktuellen templates[*] Domain-Contract nutzen.']
+]);
+
+function isBoundaryValue(value) {
+  if (typeof value !== 'string') {
+    return false;
+  }
+
+  return value.endsWith('.js')
+    || value.startsWith('http://')
+    || value.startsWith('https://')
+    || value.startsWith('cdn:')
+    || value.includes('/components/');
+}
+
+function walk(value, pointer, visit) {
+  if (Array.isArray(value)) {
+    value.forEach((entry, index) => walk(entry, `${pointer}/${index}`, visit));
+    return;
+  }
+
+  if (!value || typeof value !== 'object') {
+    return;
+  }
+
+  Object.entries(value).forEach(([key, entry]) => {
+    const childPointer = `${pointer}/${key.replace(/~/g, '~0').replace(/\//g, '~1')}`;
+    visit(key, entry, childPointer);
+    walk(entry, childPointer, visit);
+  });
+}
+
+function createBoundaryPolicyRule() {
+  return {
+    id: 'rmt.boundary-policy',
+    description: 'Verhindert Runtime-Imports, CDN-Felder und bekannte Deprecated Fields im RMT-Sprachkern.',
+    defaultSeverity: 'error',
+    run(context) {
+      const diagnostics = [];
+
+      walk(context.document, '', (key, value, pointer) => {
+        if (BOUNDARY_FIELD_NAMES.has(key) && isBoundaryValue(value)) {
+          diagnostics.push(context.createDiagnostic({
+            code: 'rmt.xtend.kernel-boundary.violation',
+            message: `RMT Record darf kein Runtime-Modul ueber "${key}" einbetten.`,
+            pointer
+          }));
+        }
+
+        if (DEPRECATED_FIELDS.has(key)) {
+          diagnostics.push(context.createDiagnostic({
+            code: 'rmt.deprecated.field.used',
+            message: `${key} ist deprecated. ${DEPRECATED_FIELDS.get(key)}`,
+            pointer
+          }));
+        }
+      });
+
+      return diagnostics;
+    }
+  };
+}
+
+module.exports = {
+  BOUNDARY_FIELD_NAMES,
+  DEPRECATED_FIELDS,
+  createBoundaryPolicyRule
+};

package/tools/rmt-language/rules/document-policy.js

@@ -0,0 +1,65 @@
+const IDENTITY_DOMAINS = ['adapters', 'components', 'routes', 'schedules', 'templates'];
+const REQUIRED_PRODUCTIVE_DOMAINS = ['adapters', 'components', 'routes', 'schedules', 'templates'];
+
+function isObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value);
+}
+
+function createDocumentPolicyRule() {
+  return {
+    id: 'rmt.document-policy',
+    description: 'Validiert Dokumentkind, Top-Level-Domains und stabile IDs.',
+    defaultSeverity: 'error',
+    run(context) {
+      const diagnostics = [];
+      const document = context.document || {};
+      const allowedDomains = new Set(context.allowedTopLevelDomains);
+
+      if (document.kind !== 'rmt_document') {
+        diagnostics.push(context.createDiagnostic({
+          code: 'rmt.document.kind.missing',
+          message: 'RMT Dokumente muessen kind: "rmt_document" deklarieren.',
+          pointer: Object.prototype.hasOwnProperty.call(document, 'kind') ? '/kind' : null
+        }));
+      }
+
+      Object.keys(document).forEach((key) => {
+        if (!allowedDomains.has(key)) {
+          diagnostics.push(context.createDiagnostic({
+            code: 'rmt.domain.unknown',
+            message: `Top-Level-Domain "${key}" ist im RMT Authoring Contract nicht registriert.`,
+            pointer: `/${context.escapeJsonPointerSegment(key)}`
+          }));
+        }
+      });
+
+      REQUIRED_PRODUCTIVE_DOMAINS.forEach((domain) => {
+        if (!Array.isArray(document[domain])) {
+          diagnostics.push(context.createDiagnostic({
+            code: 'rmt.domain.required.missing',
+            message: `Produktive RMT-Domain "${domain}" fehlt oder ist kein Array.`,
+            pointer: null
+          }));
+        }
+      });
+
+      IDENTITY_DOMAINS.forEach((domain) => {
+        context.toArray(document[domain]).forEach((record, index) => {
+          if (!isObject(record) || !context.normalizeString(record.id)) {
+            diagnostics.push(context.createDiagnostic({
+              code: 'rmt.id.missing',
+              message: `${domain}[${index}] benoetigt eine stabile id.`,
+              pointer: context.joinPointer(domain, index)
+            }));
+          }
+        });
+      });
+
+      return diagnostics;
+    }
+  };
+}
+
+module.exports = {
+  createDocumentPolicyRule
+};

package/tools/rmt-language/rules/index.js

@@ -0,0 +1,29 @@
+const {
+  createBoundaryPolicyRule
+} = require('./boundary-policy');
+const {
+  createDocumentPolicyRule
+} = require('./document-policy');
+const {
+  createRoutePolicyRule
+} = require('./route-policy');
+const {
+  createSchedulerPolicyRule
+} = require('./scheduler-policy');
+const {
+  createTemplatePolicyRule
+} = require('./template-policy');
+
+function getDefaultRmtLinterRules() {
+  return [
+    createDocumentPolicyRule(),
+    createRoutePolicyRule(),
+    createTemplatePolicyRule(),
+    createSchedulerPolicyRule(),
+    createBoundaryPolicyRule()
+  ];
+}
+
+module.exports = {
+  getDefaultRmtLinterRules
+};

package/tools/rmt-language/rules/route-policy.js

@@ -0,0 +1,81 @@
+function hasRouteTitle(route) {
+  const metadata = route && route.metadata && typeof route.metadata === 'object' ? route.metadata : {};
+
+  return Boolean(
+    route
+      && (
+        typeof route.documentTitle === 'string'
+        || typeof route.title === 'string'
+        || typeof metadata.documentTitle === 'string'
+        || typeof metadata.title === 'string'
+        || typeof metadata.titleTemplate === 'string'
+      )
+  );
+}
+
+function hasRouteAnnouncement(route) {
+  const metadata = route && route.metadata && typeof route.metadata === 'object' ? route.metadata : {};
+  const a11y = metadata.a11y && typeof metadata.a11y === 'object' ? metadata.a11y : {};
+
+  return Boolean(
+    typeof metadata.announcement === 'string'
+      || typeof metadata.routeAnnouncement === 'string'
+      || typeof a11y.announcement === 'string'
+      || typeof a11y.label === 'string'
+  );
+}
+
+function isValidRoutePath(value) {
+  return typeof value === 'string'
+    && value.trim().length > 0
+    && (
+      value === '*'
+      || value.startsWith('/')
+      || value.startsWith('#/')
+    );
+}
+
+function createRoutePolicyRule() {
+  return {
+    id: 'rmt.route-policy',
+    description: 'Validiert Route Paths, SEO-Titel und A11y-Ankuendigungen.',
+    defaultSeverity: 'error',
+    run(context) {
+      const diagnostics = [];
+
+      context.toArray(context.document.routes).forEach((route, index) => {
+        const routePointer = context.joinPointer('routes', index);
+
+        if (!isValidRoutePath(route && route.path)) {
+          diagnostics.push(context.createDiagnostic({
+            code: 'rmt.route.path.invalid',
+            message: `Route "${route && route.id ? route.id : index}" benoetigt einen gueltigen path.`,
+            pointer: `${routePointer}/path`
+          }));
+        }
+
+        if (!hasRouteTitle(route)) {
+          diagnostics.push(context.createDiagnostic({
+            code: 'rmt.route.document-title.missing',
+            message: `Route "${route && route.id ? route.id : index}" sollte einen Seitentitel fuer SPA/SEO-Rewrites definieren.`,
+            pointer: routePointer
+          }));
+        }
+
+        if (!hasRouteAnnouncement(route)) {
+          diagnostics.push(context.createDiagnostic({
+            code: 'rmt.a11y.route-announcement.missing',
+            message: `Route "${route && route.id ? route.id : index}" sollte eine A11y-Ankuendigung fuer Screenreader definieren.`,
+            pointer: routePointer
+          }));
+        }
+      });
+
+      return diagnostics;
+    }
+  };
+}
+
+module.exports = {
+  createRoutePolicyRule
+};

package/tools/rmt-language/rules/scheduler-policy.js

@@ -0,0 +1,66 @@
+const KNOWN_HYDRATION_POLICIES = new Set([
+  'runtime_render',
+  'hydrate_prerendered',
+  'managed_subtree',
+  'manual',
+  'none',
+  'lazy',
+  'idle',
+  'visible'
+]);
+
+function createSchedulerPolicyRule() {
+  return {
+    id: 'rmt.scheduler-policy',
+    description: 'Validiert Schedule Endpoints und bekannte Hydration Policies.',
+    defaultSeverity: 'warning',
+    run(context) {
+      const diagnostics = [];
+
+      context.toArray(context.document.schedules).forEach((schedule, index) => {
+        const pointer = context.joinPointer('schedules', index);
+
+        if (!context.normalizeString(schedule && schedule.endpointName)) {
+          diagnostics.push(context.createDiagnostic({
+            code: 'rmt.schedule.endpoint.missing',
+            message: `Schedule "${schedule && schedule.id ? schedule.id : index}" sollte endpointName definieren.`,
+            pointer
+          }));
+        }
+      });
+
+      context.toArray(context.document.components).forEach((component, index) => {
+        const hydration = component && component.hydration;
+        const mode = hydration && context.normalizeString(hydration.mode);
+
+        if (mode && !KNOWN_HYDRATION_POLICIES.has(mode)) {
+          diagnostics.push(context.createDiagnostic({
+            code: 'rmt.hydration.policy.unknown',
+            message: `Component "${component && component.id ? component.id : index}" nutzt unbekannte Hydration Policy "${mode}".`,
+            pointer: context.joinPointer('components', index, 'hydration', 'mode')
+          }));
+        }
+      });
+
+      context.toArray(context.document.templates).forEach((template, index) => {
+        const hydration = template && template.hydration;
+        const mode = hydration && context.normalizeString(hydration.mode);
+
+        if (mode && !KNOWN_HYDRATION_POLICIES.has(mode)) {
+          diagnostics.push(context.createDiagnostic({
+            code: 'rmt.hydration.policy.unknown',
+            message: `Template "${template && template.id ? template.id : index}" nutzt unbekannte Hydration Policy "${mode}".`,
+            pointer: context.joinPointer('templates', index, 'hydration', 'mode')
+          }));
+        }
+      });
+
+      return diagnostics;
+    }
+  };
+}
+
+module.exports = {
+  KNOWN_HYDRATION_POLICIES,
+  createSchedulerPolicyRule
+};