openyida 2026.7.19 → 2026.7.21

package/lib/app/services/canvas-page-compiler.js

@@ -0,0 +1,91 @@
+'use strict';
+
+const crypto = require('crypto');
+const { compileCanvasLocal } = require('../canvas-compile');
+const { schemaError } = require('../../schema/errors');
+const { isLoadedPageSource } = require('../../schema/page-source-loader');
+
+const CANVAS_PAGE_PROFILE = 'canvas/default';
+const COMPILED_CANVAS_PAGES = new WeakSet();
+
+function compileCanvasPageSource(loadedSource) {
+  if (!isLoadedPageSource(loadedSource)) {
+    compilerError('SCHEMA_PAGE_SOURCE_INVALID', 'Canvas page compiler requires a trusted page source.');
+  }
+  if (typeof loadedSource.source !== 'string' || loadedSource.source.trim() === '') {
+    compilerError('SCHEMA_PAGE_SOURCE_COMPILE_FAILED', 'Canvas page source did not pass local validation.', {
+      stage: 'canvas',
+    });
+  }
+
+  let canvasResult;
+  try {
+    canvasResult = compileCanvasLocal(loadedSource.source);
+  } catch (error) {
+    compilerError('SCHEMA_PAGE_SOURCE_COMPILE_FAILED', 'Canvas page source could not be compiled.', {
+      stage: 'canvas',
+    });
+  }
+
+  if (
+    !canvasResult ||
+    typeof canvasResult.runtimeCode !== 'string' ||
+    !canvasResult.runtimeCode ||
+    !/\bYidaComp\b/.test(canvasResult.runtimeCode) ||
+    typeof canvasResult.importedModules !== 'string' ||
+    !isJsonArrayString(canvasResult.importedModules)
+  ) {
+    compilerError('SCHEMA_PAGE_SOURCE_COMPILE_FAILED', 'Canvas page output did not match the runtime contract.', {
+      stage: 'canvas',
+    });
+  }
+
+  const result = Object.freeze({
+    compiledHash: createCanvasCompiledHash(
+      canvasResult.runtimeCode,
+      canvasResult.importedModules
+    ),
+    importedModules: canvasResult.importedModules,
+    inputHash: loadedSource.sourceHash,
+    profile: CANVAS_PAGE_PROFILE,
+    runtimeCode: canvasResult.runtimeCode,
+    source: loadedSource.source,
+    sourceHash: createSha256(loadedSource.source),
+  });
+  COMPILED_CANVAS_PAGES.add(result);
+  return result;
+}
+
+function isCompiledCanvasPage(value) {
+  return !!(value && typeof value === 'object' && COMPILED_CANVAS_PAGES.has(value));
+}
+
+function createCanvasCompiledHash(runtimeCode, importedModules) {
+  return createSha256(JSON.stringify({
+    importedModules: String(importedModules || ''),
+    runtimeCode: String(runtimeCode || ''),
+  }));
+}
+
+function isJsonArrayString(value) {
+  try {
+    return Array.isArray(JSON.parse(value));
+  } catch {
+    return false;
+  }
+}
+
+function createSha256(value) {
+  return 'sha256:' + crypto.createHash('sha256').update(value).digest('hex');
+}
+
+function compilerError(code, message, details) {
+  throw schemaError(code, message, details ? { details } : undefined);
+}
+
+module.exports = {
+  CANVAS_PAGE_PROFILE,
+  compileCanvasPageSource,
+  createCanvasCompiledHash,
+  isCompiledCanvasPage,
+};

package/lib/app/services/canvas-page-schema-builder.js

@@ -0,0 +1,149 @@
+'use strict';
+
+const {
+  createNodeIdGenerator,
+  generateSuffix,
+  getGlobalDataSourceFitConfig,
+} = require('./native-page-schema-builder');
+
+const CANVAS_ACTIONS_SOURCE = 'export function didMount() {}';
+const CANVAS_ACTIONS_COMPILED = '"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.didMount=didMount;function didMount(){}';
+
+function buildCanvasPageSchemaContent(sourceCode, runtimeCode, importedModules, formUuid, options = {}) {
+  return JSON.stringify(buildCanvasPageSchemaObject(
+    sourceCode,
+    runtimeCode,
+    importedModules,
+    formUuid,
+    options
+  ));
+}
+
+function buildCanvasPageSchemaObject(sourceCode, runtimeCode, importedModules, formUuid, options = {}) {
+  const nextNodeId = resolveSchemaBuilderDependency(
+    options.nextNodeId,
+    createNodeIdGenerator,
+    'nextNodeId'
+  );
+  const nextSuffix = resolveSchemaBuilderDependency(
+    options.nextSuffix,
+    () => generateSuffix,
+    'nextSuffix'
+  );
+  const constructorCode = "function constructor() {\nvar module = { exports: {} };\nvar _this = this;\nthis.__initMethods__(module.exports, module);\nObject.keys(module.exports).forEach(function(item) {\n  if(typeof module.exports[item] === 'function'){\n    _this[item] = module.exports[item];\n  }\n});\n\n}";
+
+  return {
+    schemaType: 'superform',
+    schemaVersion: '5.0',
+    pages: [
+      {
+        utils: [
+          {
+            name: 'legaoBuiltin',
+            type: 'npm',
+            content: { package: '@ali/vu-legao-builtin', version: '3.0.0', exportName: 'legaoBuiltin' },
+          },
+          {
+            name: 'yidaPlugin',
+            type: 'npm',
+            content: { package: '@ali/vu-yida-plugin', version: '1.1.0', exportName: 'yidaPlugin' },
+          },
+        ],
+        componentsMap: [
+          { package: '@ali/vc-deep-yida', version: '1.5.169', componentName: 'YidaCodeCanvas' },
+          { package: '@ali/vc-deep-yida', version: '1.5.169', componentName: 'RootHeader' },
+          { package: '@ali/vc-deep-yida', version: '1.5.169', componentName: 'RootContent' },
+          { package: '@ali/vc-deep-yida', version: '1.5.169', componentName: 'RootFooter' },
+          { package: '@ali/vc-deep-yida', version: '1.5.169', componentName: 'Page' },
+        ],
+        componentsTree: [
+          {
+            componentName: 'Page',
+            id: nextNodeId(),
+            props: {
+              contentBgColor: 'white',
+              pageStyle: { backgroundColor: '#f2f3f5' },
+              contentMargin: '0',
+              contentPadding: '0',
+              showTitle: false,
+              contentPaddingMobile: '0',
+              templateVersion: '1.0.0',
+              contentMarginMobile: '0',
+              className: 'page_' + nextSuffix(),
+              contentBgColorMobile: 'white',
+            },
+            condition: true,
+            css: 'body{background-color:#f2f3f5}.vc-page-yida-page{--yida-form-content-padding:0;--yida-form-content-margin:0;--yida-layout-padding:0}.vc-deep-container-entry.vc-rootcontent{padding:0!important;margin-top:0!important;margin-right:0!important;margin-bottom:0!important;margin-left:0!important}',
+            methods: {
+              __initMethods__: {
+                type: 'js',
+                source: 'function (exports, module) { /*set actions code here*/ }',
+                compiled: 'function (exports, module) { /*set actions code here*/ }',
+              },
+            },
+            dataSource: {
+              offline: [],
+              globalConfig: getGlobalDataSourceFitConfig(),
+              online: [],
+              list: [],
+              sync: true,
+            },
+            lifeCycles: {
+              constructor: { type: 'js', compiled: constructorCode, source: constructorCode },
+              componentWillUnmount: '',
+              componentDidMount: { name: 'didMount', id: 'didMount', params: {}, type: 'actionRef' },
+            },
+            hidden: false,
+            title: '',
+            isLocked: false,
+            conditionGroup: '',
+            children: [
+              {
+                componentName: 'YidaCodeCanvas',
+                id: nextNodeId(),
+                props: {
+                  code: sourceCode,
+                  runtimeCode,
+                  pageType: 'application',
+                  isWebCCompiled: true,
+                  componentProps: {},
+                  importedModules: importedModules || '',
+                },
+                condition: true,
+                hidden: false,
+                title: '',
+                isLocked: false,
+                conditionGroup: '',
+              },
+            ],
+          },
+        ],
+        id: formUuid,
+        connectComponent: [],
+      },
+    ],
+    actions: {
+      module: { compiled: CANVAS_ACTIONS_COMPILED, source: CANVAS_ACTIONS_SOURCE },
+      type: 'FUNCTION',
+      list: [{ id: 'didMount', title: 'didMount' }],
+    },
+    config: { connectComponent: [] },
+  };
+}
+
+function resolveSchemaBuilderDependency(value, createDefault, property) {
+  if (value === undefined) {
+    return createDefault();
+  }
+  if (typeof value !== 'function') {
+    throw new TypeError(`buildCanvasPageSchemaContent ${property} must be a function`);
+  }
+  return value;
+}
+
+module.exports = Object.freeze({
+  CANVAS_ACTIONS_COMPILED,
+  CANVAS_ACTIONS_SOURCE,
+  buildCanvasPageSchemaContent,
+  buildCanvasPageSchemaObject,
+});

package/lib/app/services/field-bindings.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const { normalizeSchemaFields } = require('../schema-field-resolution');
+
+function normalizeSchemaResult(schemaResult) {
+  if (schemaResult && schemaResult.content) {
+    return schemaResult;
+  }
+  return { content: schemaResult || {} };
+}
+
+function normalizeExpectedBinding(value) {
+  if (typeof value === 'string') {
+    return { fieldId: value };
+  }
+  if (value && typeof value === 'object') {
+    const fieldId = value.fieldId || value.id || value.value || '';
+    return Object.assign({}, value, { fieldId: String(fieldId || '') });
+  }
+  return { fieldId: '' };
+}
+
+function verifyFieldBindings(schemaResult, expectedBindings, options) {
+  const expectedComponentTypes = options && options.expectedComponentTypes || {};
+  const fields = normalizeSchemaFields(normalizeSchemaResult(schemaResult));
+  const fieldsById = new Map();
+  fields.forEach(function (field) {
+    if (field.fieldId) {
+      fieldsById.set(field.fieldId, field);
+    }
+  });
+
+  const verification = {
+    verified: [],
+    missing: [],
+    mismatched: [],
+  };
+
+  Object.keys(expectedBindings || {}).forEach(function (semanticPath) {
+    const expected = normalizeExpectedBinding(expectedBindings[semanticPath]);
+    const fieldId = expected.fieldId;
+    const expectedComponentType = expected.componentType || expected.componentName || expectedComponentTypes[semanticPath] || '';
+
+    if (!fieldId || !fieldsById.has(fieldId)) {
+      verification.missing.push({ semanticPath, fieldId });
+      return;
+    }
+
+    const actual = fieldsById.get(fieldId);
+    if (expectedComponentType && actual.componentType !== expectedComponentType) {
+      verification.mismatched.push({
+        semanticPath,
+        fieldId,
+        expectedComponentType,
+        actualComponentType: actual.componentType,
+      });
+      return;
+    }
+
+    verification.verified.push(semanticPath);
+  });
+
+  return verification;
+}
+
+module.exports = {
+  verifyFieldBindings,
+};