@ccslabs/xtend 0.1.0-rc.1 → 0.1.2

package/catalog/type-exports-rmt.js

@@ -25,7 +25,15 @@ const RMT_SHARED_DECLARATION_FILE = 'tools/rmt-language/rmt-tooling-public-types
 
 const RMT_RUNTIME_PACKAGE_EXPORTS = Object.freeze([
   './rmt',
-  './rmt/browser'
+  './rmt/browser',
+  './rmt/dom-descriptor-renderer',
+  './rmt/component-capability-registry',
+  './rmt/state-selector-runtime',
+  './rmt/action-effect-runtime',
+  './rmt/event-routing-runtime',
+  './rmt/surface-resource-graph-runtime',
+  './rmt/native-shell-runtime',
+  './rmt/node-ssr-adapter'
 ]);
 
 const RMT_TOOLING_PACKAGE_EXPORTS = Object.freeze([
@@ -72,6 +80,7 @@ const RMT_TOOLING_PACKAGE_EXPORTS = Object.freeze([
   './rmt-language/symbols',
   './rmt-language/definitions',
   './rmt-language/code-actions',
+  './rmt-language/app-platform-tooling',
   './rmt-language-server',
   './rmt-language-server/protocol',
   './rmt-linter/cli',
@@ -106,6 +115,7 @@ const RMT_REPRESENTATIVE_DECLARATION_TOKENS = Object.freeze({
   'tools/rmt-language/vnext-compiler.d.ts': ['RmtCompileResult', 'createRmtVNextCompiler', 'compileRmtVNextSource'],
   'tools/rmt-language/vnext-tooling.d.ts': ['RmtCompletionItem', 'RmtHover', 'RmtDocumentSymbol', 'getRmtVNextToolingCompletions'],
   'tools/rmt-language/diagnostics.d.ts': ['RmtToolingDiagnostic', 'createRmtLinter', 'lintRmtSource'],
+  'tools/rmt-language/app-platform-tooling.d.ts': ['RmtAppPlatformToolingReport', 'analyzeRmtAppPlatformSource', 'createRmtAppPlatformScaffoldPlan'],
   'tools/rmt-language/code-actions.d.ts': ['RmtCodeAction', 'RmtWorkspaceEdit', 'getRmtCodeActions'],
   'tools/rmt-language/kernel-panic-monitor.d.ts': ['RmtKernelPanicMonitor', 'RmtKernelPanicState', 'createKernelPanicMonitor'],
   'tools/rmt-language/kernel-recovery.d.ts': ['RmtKernelRecoveryController', 'RmtKernelRecoveryOutcome', 'createKernelRecoveryController'],
@@ -113,6 +123,8 @@ const RMT_REPRESENTATIVE_DECLARATION_TOKENS = Object.freeze({
   'tools/rmt-language/kernel-scheduler-failure.d.ts': ['RmtKernelSchedulerFailureController', 'RmtKernelSchedulerFailureRecord', 'createKernelSchedulerFailureController'],
   'tools/rmt-language/kernel-policy-parity.d.ts': ['RmtKernelPolicyParityController', 'RmtKernelPolicyParityReport', 'createKernelPolicyParityController'],
   'tools/rmt-language/kernel-security-regression.d.ts': ['RmtKernelSecurityRegressionReport', 'RmtKernelSecurityRegressionFixtureSet', 'createKernelSecurityRegressionFixtures'],
+  'xtendrmt/rmt-component-capability-registry.d.ts': ['RmtComponentCapabilityRegistry', 'RmtComponentCapability', 'createRmtComponentCapabilityRegistry'],
+  'xtendrmt/rmt-node-ssr-adapter.d.ts': ['RmtNodeSsrAdapter', 'RmtNodeSsrRenderResult', 'RmtNodeSsrJsonlFrame', 'createRmtNodeSsrAdapter'],
   'tools/rmt-language-server/protocol.d.ts': ['RmtJsonRpcMessage', 'encodeProtocolMessage', 'parseProtocolMessages'],
   'tools/rmt-language-server/server.d.ts': ['RmtLanguageServiceProvider', 'RmtLanguageServer', 'createRmtLanguageServer'],
   'tools/rmt-linter/reporter.d.ts': ['RmtLanguageServiceReport', 'createRmtAgentRepairReport'],
@@ -173,6 +185,14 @@ function getRuntimeTarget(packageManifest, exportKey) {
 
 function resolveDeclarationForExport(exportKey) {
   if (exportKey === './rmt' || exportKey === './rmt/browser') return './xtendrmt/rmt-core.d.ts';
+  if (exportKey === './rmt/dom-descriptor-renderer') return './xtendrmt/rmt-dom-descriptor-renderer.d.ts';
+  if (exportKey === './rmt/component-capability-registry') return './xtendrmt/rmt-component-capability-registry.d.ts';
+  if (exportKey === './rmt/state-selector-runtime') return './xtendrmt/rmt-state-selector-runtime.d.ts';
+  if (exportKey === './rmt/action-effect-runtime') return './xtendrmt/rmt-action-effect-runtime.d.ts';
+  if (exportKey === './rmt/event-routing-runtime') return './xtendrmt/rmt-event-routing-runtime.d.ts';
+  if (exportKey === './rmt/surface-resource-graph-runtime') return './xtendrmt/rmt-surface-resource-graph-runtime.d.ts';
+  if (exportKey === './rmt/native-shell-runtime') return './xtendrmt/rmt-native-shell-runtime.d.ts';
+  if (exportKey === './rmt/node-ssr-adapter') return './xtendrmt/rmt-node-ssr-adapter.d.ts';
   if (exportKey === './rmt-language/snippets') return './tools/rmt-language/snippets/index.d.ts';
   if (exportKey === './rmt-language-server') return './tools/rmt-language-server/server.d.ts';
   if (exportKey === './rmt-language-server/protocol') return './tools/rmt-language-server/protocol.d.ts';
@@ -185,6 +205,14 @@ function resolveDeclarationForExport(exportKey) {
 function resolveSourceForExport(exportKey) {
   if (exportKey === './rmt') return './xtendrmt/rmt-runtime.esm.js';
   if (exportKey === './rmt/browser') return './xtendrmt/rmt-runtime.browser.js';
+  if (exportKey === './rmt/dom-descriptor-renderer') return './xtendrmt/rmt-dom-descriptor-renderer.js';
+  if (exportKey === './rmt/component-capability-registry') return './xtendrmt/rmt-component-capability-registry.js';
+  if (exportKey === './rmt/state-selector-runtime') return './xtendrmt/rmt-state-selector-runtime.js';
+  if (exportKey === './rmt/action-effect-runtime') return './xtendrmt/rmt-action-effect-runtime.js';
+  if (exportKey === './rmt/event-routing-runtime') return './xtendrmt/rmt-event-routing-runtime.js';
+  if (exportKey === './rmt/surface-resource-graph-runtime') return './xtendrmt/rmt-surface-resource-graph-runtime.js';
+  if (exportKey === './rmt/native-shell-runtime') return './xtendrmt/rmt-native-shell-runtime.js';
+  if (exportKey === './rmt/node-ssr-adapter') return './xtendrmt/rmt-node-ssr-adapter.js';
   if (exportKey === './rmt-language/snippets') return './tools/rmt-language/snippets/index.js';
   if (exportKey === './rmt-language-server') return './tools/rmt-language-server/server.js';
   if (exportKey === './rmt-language-server/protocol') return './tools/rmt-language-server/protocol.js';
@@ -196,6 +224,14 @@ function resolveSourceForExport(exportKey) {
 
 const RMT_DECLARATION_FILES = Object.freeze([
   'xtendrmt/rmt-core.d.ts',
+  'xtendrmt/rmt-dom-descriptor-renderer.d.ts',
+  'xtendrmt/rmt-component-capability-registry.d.ts',
+  'xtendrmt/rmt-state-selector-runtime.d.ts',
+  'xtendrmt/rmt-action-effect-runtime.d.ts',
+  'xtendrmt/rmt-event-routing-runtime.d.ts',
+  'xtendrmt/rmt-surface-resource-graph-runtime.d.ts',
+  'xtendrmt/rmt-native-shell-runtime.d.ts',
+  'xtendrmt/rmt-node-ssr-adapter.d.ts',
   RMT_SHARED_DECLARATION_FILE,
   ...RMT_TOOLING_PACKAGE_EXPORTS.map((exportKey) => toRepoRelative(resolveDeclarationForExport(exportKey)))
 ]);

package/catalog/type-exports.js

@@ -29,8 +29,8 @@ const TYPE_EXPORTS_RELEASE_STATUS = 'accepted-productive-type-exports-release-ga
 const TYPE_EXPORTS_RELEASE_TARGET = 'productive-type-exports-release-gate-ready';
 const TYPE_EXPORTS_RELEASE_PACKAGE_SCRIPT = 'npm run test:type-exports:release';
 const TYPE_EXPORTS_RELEASE_LOCAL_GATE = 'node scripts/run_xtend_tests.js type-exports type-exports-loader type-exports-api type-exports-rmt type-exports-policy type-exports-builder type-exports-catalog type-exports-vendor --report .xtend-test-results/xtend-type-exports-report.json';
-const TYPE_EXPORTS_LOCKED_EXPORT_COUNT = 115;
-const TYPE_EXPORTS_LOCKED_EXPORT_FINGERPRINT = '276e93d51ccfb779d1e5750cf6d3f80b58aaa57c68b95417c6df5fe4ba0ae62d';
+const TYPE_EXPORTS_LOCKED_EXPORT_COUNT = 124;
+const TYPE_EXPORTS_LOCKED_EXPORT_FINGERPRINT = '7db9e94070275839ca10af3933a11eccc957d0b973b4cc18f43538d20556a861';
 
 const TYPE_EXPORTS_COMPLETED_WORKPACKAGES = Object.freeze([
   'WP-TypeExports-01',
@@ -115,7 +115,7 @@ const TYPE_EXPORT_GROUPS = Object.freeze([
     id: 'rmt-runtime',
     priority: 'P1',
     workpackage: 'WP-TypeExports-04',
-    exports: ['./rmt', './rmt/browser'],
+    exports: ['./rmt', './rmt/browser', './rmt/dom-descriptor-renderer', './rmt/component-capability-registry', './rmt/state-selector-runtime', './rmt/action-effect-runtime', './rmt/event-routing-runtime', './rmt/surface-resource-graph-runtime', './rmt/native-shell-runtime', './rmt/node-ssr-adapter'],
     strategy: 'runtime-types-condition-to-rmt-core'
   },
   {

package/components/icon-packs/lucide.js

@@ -65,6 +65,10 @@ const icons = Object.freeze({
     aliases: ['performance', 'speed'],
     nodes: [path('M4 14a8 8 0 1 1 16 0'), path('M12 14l4-4'), path('M6.3 18h11.4')]
   },
+  globe: {
+    aliases: ['language', 'locale', 'i18n'],
+    nodes: [circle(12, 12, 10), path('M2 12h20'), path('M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10Z')]
+  },
   layers: {
     aliases: ['platform'],
     nodes: [path('M12 3 3 8l9 5 9-5Z'), path('m3 13 9 5 9-5'), path('m3 18 9 5 9-5')]

package/components/manifest.json

@@ -31,6 +31,8 @@
   "x-status": "./xstatus.js",
   "x-summary": "./xsummary.js",
   "x-surface-manager": "./xsurfacemanager.js",
+  "x-surface-portal": "./xsurfaceportal.js",
+  "x-surface-region": "./xsurfaceregion.js",
   "x-surface-window": "./xsurfacewindow.js",
   "x-tabs": "./xtabs.js",
   "x-textarea": "./xtextarea.js",

package/components/prism-rmt.d.ts

@@ -0,0 +1,34 @@
+export interface XtendRmtPrismHighlightInput {
+  code: string;
+  language?: string;
+  rawLanguage?: string;
+}
+
+export interface XtendRmtPrismHighlightResult {
+  html: string;
+  highlighted: boolean;
+  engine: 'prism' | 'plain-text';
+  language: string;
+}
+
+export interface XtendRmtPrismHighlighter {
+  schema: 'xtend.rmt.prism-middleware.v1';
+  highlight(input: XtendRmtPrismHighlightInput): XtendRmtPrismHighlightResult;
+}
+
+export interface XtendRmtPrismApi {
+  schema: 'xtend.rmt.prism-middleware.v1';
+  aliases: string[];
+  normalizeLanguage(language?: string): string;
+  createRmtGrammar(prism?: unknown): Record<string, unknown>;
+  register(prism: unknown): boolean;
+  createHighlighter(prism: unknown): XtendRmtPrismHighlighter;
+}
+
+declare global {
+  interface Window {
+    XTendRmtPrism?: XtendRmtPrismApi;
+  }
+}
+
+export {};

package/components/prism-rmt.js

@@ -0,0 +1,130 @@
+(function registerXtendRmtPrism(globalTarget) {
+  const RMT_PRISM_SCHEMA = 'xtend.rmt.prism-middleware.v1';
+  const LANGUAGE_ALIASES = Object.freeze({
+    rmt: 'rmt',
+    'rmt-vnext': 'rmt',
+    xtendrmt: 'rmt'
+  });
+
+  function escapeHtml(value) {
+    return String(value == null ? '' : value)
+      .replace(/&/g, '&')
+      .replace(/</g, '&lt;')
+      .replace(/>/g, '&gt;')
+      .replace(/"/g, '&quot;')
+      .replace(/'/g, '&#39;')
+      .replace(/`/g, '&#96;');
+  }
+
+  function normalizeLanguage(language) {
+    const value = String(language || 'text').trim().toLowerCase();
+    return LANGUAGE_ALIASES[value] || value || 'text';
+  }
+
+  function createRmtGrammar() {
+    return {
+      comment: [
+        { pattern: /\/\/.*/, greedy: true },
+        { pattern: /\/\*[\s\S]*?(?:\*\/|$)/, greedy: true }
+      ],
+      string: [
+        { pattern: /"(?:\\.|[^"\\])*"/, greedy: true },
+        { pattern: /'(?:\\.|[^'\\])*'/, greedy: true }
+      ],
+      'rmt-boundary': {
+        pattern: /\btrust\s+boundary\b/,
+        alias: ['keyword', 'rmt-boundary']
+      },
+      'rmt-remote-surface': {
+        pattern: /\bremote\s+surface\b/,
+        alias: ['keyword', 'rmt-primitive']
+      },
+      'rmt-event-binding': {
+        pattern: /\bon\s+[^\n{]+?->\s+action\b/,
+        inside: {
+          keyword: /\b(?:on|action)\b/,
+          operator: /->/,
+          string: /"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'/,
+          'rmt-reference': {
+            pattern: /\b[A-Za-z_][\w-]*(?:\.[A-Za-z_][\w-]*)+\b/,
+            alias: ['variable', 'rmt-reference']
+          },
+          punctuation: /[()[\].]/
+        }
+      },
+      'rmt-lifecycle': {
+        pattern: /\b(?:mount|hydrate|update|unmount|suspend|resume|invalidate|dispose|prewarm|recycle|detach|reattach|destroy)\b/,
+        alias: ['keyword', 'rmt-lifecycle']
+      },
+      'rmt-primitive': {
+        pattern: /\b(?:template|state|selector|datasource|action|portal|overlay|resource|surface|lane|slot|stream)\b/,
+        alias: ['keyword', 'rmt-primitive']
+      },
+      keyword: /\b(?:import|from|endpoint|sse|worker|fixture|when|sanitize|where|find|sort|by|asc|desc|output|method|contract|result|fallback|input|reduce|effect|fetch|status|emit|with|success|error|message|tone|root|layer|kind|component|source|key|bounds|weight|type|initial|preserve|repeat|releases|owner|focus|pointer|scroll|policy|close|topmost|none|restore|passthrough|lock-when-modal|target|payload|preventDefault|detail|dataset|exposes|consumes|remote|manifest|version)\b/,
+      boolean: /\b(?:true|false|null)\b/,
+      number: /\b-?(?:0x[\da-f]+|\d+(?:\.\d+)?)\b/i,
+      'rmt-component': {
+        pattern: /(\bcomponent\s+)[A-Za-z][\w-]*/,
+        lookbehind: true,
+        alias: ['class-name', 'rmt-component']
+      },
+      'rmt-reference': {
+        pattern: /\b(?:state|selector|datasource|action|portal|overlay|resource|surface|lane|input|result|record|detail|target|instance)\.[A-Za-z_][\w-]*(?:\.[A-Za-z_][\w-]*)*\b/,
+        alias: ['variable', 'rmt-reference']
+      },
+      'rmt-identifier': {
+        pattern: /\b[A-Za-z_][\w-]*(?:\.[A-Za-z_][\w-]*)+\b/,
+        alias: ['property', 'rmt-identifier']
+      },
+      operator: /->|==|!=|>=|<=|\|\||&&|[=<>]/,
+      punctuation: /[{}()[\],.]/
+    };
+  }
+
+  function register(prism) {
+    if (!prism || !prism.languages) return false;
+    const grammar = prism.languages.rmt || createRmtGrammar(prism);
+    prism.languages.rmt = grammar;
+    prism.languages['rmt-vnext'] = grammar;
+    prism.languages.xtendrmt = grammar;
+    return true;
+  }
+
+  function createHighlighter(prism) {
+    register(prism);
+    return {
+      schema: RMT_PRISM_SCHEMA,
+      highlight(input = {}) {
+        const code = String(input.code == null ? '' : input.code);
+        const language = normalizeLanguage(input.language || input.rawLanguage);
+        const grammar = prism && prism.languages && prism.languages[language];
+        if (!grammar || typeof prism.highlight !== 'function') {
+          return {
+            html: escapeHtml(code),
+            highlighted: false,
+            engine: 'plain-text',
+            language
+          };
+        }
+        return {
+          html: prism.highlight(code, grammar, language),
+          highlighted: true,
+          engine: 'prism',
+          language
+        };
+      }
+    };
+  }
+
+  const api = {
+    schema: RMT_PRISM_SCHEMA,
+    aliases: Object.keys(LANGUAGE_ALIASES),
+    normalizeLanguage,
+    createRmtGrammar,
+    register,
+    createHighlighter
+  };
+
+  globalTarget.XTendRmtPrism = api;
+  if (globalTarget.Prism) register(globalTarget.Prism);
+})(typeof window !== 'undefined' ? window : globalThis);

package/components/xcards.js

@@ -44,6 +44,19 @@ class XCards extends HTMLElement {
     };
   }
 
+  static get xtendLayoutStabilityProfile() {
+    return {
+      schema: "xtend.layout-stability.v1",
+      componentRef: "x-cards",
+      minBlockSize: "var(--cards-reserved-block-size, var(--xtend-layout-reserved-block-size, 18rem))",
+      intrinsicSize: "auto var(--cards-reserved-block-size, 18rem)",
+      slotReserve: ["default"],
+      hydrationShiftPolicy: "no-geometry-shift",
+      shellFirstCompatible: true,
+      lazyLoadingCompatible: true
+    };
+  }
+
   static get xtendLayoutDisplayMediaUxProfile() {
     return {
       schema: "xtend.component.layout-display-media-ux-profile.v1",
@@ -82,6 +95,8 @@ class XCards extends HTMLElement {
           --card-max-width: var(--xtend-layout-content-max, 1200px);
           --xtend-layout-grid-min: minmax(min(100%, 16rem), 1fr);
           /* margin und width entfernt, damit kein Overflow entsteht */
+          min-block-size: var(--cards-reserved-block-size, var(--xtend-layout-reserved-block-size, auto));
+          contain-intrinsic-size: auto var(--cards-reserved-block-size, var(--xtend-layout-reserved-block-size, 18rem));
         }
         .grid {
           display: grid;

package/components/xcode.d.ts

@@ -1,8 +1,28 @@
 import type { XtendCustomEventMap, XtendLayoutDisplayMediaUxProfile, XtendPublicEventContract } from './xtend-public-types';
 
-export type XCodeAttributeName = 'lang';
+export type XCodeAttributeName = 'lang' | 'language';
 export type XCodeEventName = 'code-copied';
 export type XCodeLayoutDisplayMediaUxProfile = XtendLayoutDisplayMediaUxProfile<'x-code'>;
+export type XCodeHighlightEngine = 'prism' | 'plain-text' | string;
+
+export interface XCodeHighlightInput {
+  code: string;
+  language: string;
+  rawLanguage?: string;
+  languageAlias?: XCodeAttributeName | 'default';
+  element?: XCodeElement;
+}
+
+export interface XCodeHighlightResult {
+  html: string;
+  highlighted: boolean;
+  engine: XCodeHighlightEngine;
+  language: string;
+}
+
+export type XCodeHighlighter = ((input: XCodeHighlightInput) => XCodeHighlightResult) | {
+  highlight(input: XCodeHighlightInput): XCodeHighlightResult;
+};
 
 export interface XCodeSnapshot {
   schema: 'xtend.component.layout-display-media-snapshot.v1';
@@ -10,7 +30,12 @@ export interface XCodeSnapshot {
   stateKey: string;
   schedule: 'component.idle.hydrate';
   lang: string;
+  language: string;
   codeLength: number;
+  highlighted: boolean;
+  highlightEngine: XCodeHighlightEngine;
+  highlightLanguage: string;
+  languageAlias: XCodeAttributeName | 'default';
 }
 
 export interface XCodeEventDetailMap {
@@ -26,10 +51,20 @@ export interface XCodeElement extends HTMLElement {
   addEventListener<K extends keyof XCodeEventMap>(type: K, listener: (event: XCodeEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
 }
 
+export interface XCodeConstructor {
+  new (): XCodeElement;
+  registerHighlighter(provider: XCodeHighlighter | null): XCodeHighlighter | null;
+  getHighlighter(): XCodeHighlighter | null;
+}
+
 declare global {
   interface HTMLElementTagNameMap {
     'x-code': XCodeElement;
   }
+
+  interface Window {
+    XTendXCodeHighlighter?: XCodeHighlighter;
+  }
 }
 
 export {};