openyida 2026.5.21 → 2026.5.25

package/lib/app/import-app.js

@@ -52,15 +52,26 @@ async function createApp(appName, authRef) {
   return result.content; // appType
 }
 
-// ── 创建空白表单页面 ──────────────────────────────────
+function normalizeImportFormType(formType) {
+  const normalized = String(formType || '').trim().toLowerCase();
+  if (!normalized || normalized === 'form') {
+    return 'receipt';
+  }
+  return normalized;
+}
 
-async function createBlankForm(appType, formTitle, authRef) {
-  const postData = querystring.stringify({
-    _csrf_token: authRef.csrfToken,
-    formType: 'receipt',
+function buildCreateFormPostData(csrfToken, formTitle, formType = 'receipt') {
+  return querystring.stringify({
+    _csrf_token: csrfToken,
+    formType: normalizeImportFormType(formType),
     title: JSON.stringify(buildYidaI18n(formTitle, { en_US: formTitle, ja_JP: formTitle })),
   });
+}
 
+// ── 创建空白表单/页面/报表 ──────────────────────────────
+
+async function createBlankForm(appType, formTitle, authRef, formType = 'receipt') {
+  const postData = buildCreateFormPostData(authRef.csrfToken, formTitle, formType);
   const result = await requestWithAutoLogin((auth) => {
     return httpPost(
       auth.baseUrl,
@@ -80,14 +91,18 @@ async function createBlankForm(appType, formTitle, authRef) {
 
 // ── 保存表单 Schema ───────────────────────────────────
 
-async function saveFormSchema(appType, formUuid, schema, authRef) {
-  const postData = querystring.stringify({
+async function saveFormSchema(appType, formUuid, schema, authRef, formType = 'receipt') {
+  const payload = {
     _csrf_token: authRef.csrfToken,
     appType,
     formUuid,
     content: JSON.stringify(schema),
     schemaVersion: 'V5',
-  });
+  };
+  if (normalizeImportFormType(formType) === 'report') {
+    payload.importSchema = 'true';
+  }
+  const postData = querystring.stringify(payload);
 
   const result = await requestWithAutoLogin((auth) => {
     return httpPost(
@@ -234,12 +249,13 @@ async function run(args) {
 
   for (const form of forms) {
     const { formUuid: oldFormUuid, name: formName, schema: formSchemaResult } = form;
+    const formType = normalizeImportFormType(form.formType);
     info(t('import.migrating', formName, oldFormUuid));
 
     // 4.1 创建空白表单
     let newFormUuid;
     try {
-      newFormUuid = await createBlankForm(newAppType, formName, authRef);
+      newFormUuid = await createBlankForm(newAppType, formName, authRef, formType);
       success(t('import.blank_form_created', newFormUuid));
     } catch (err) {
       fail(t('import.create_form_failed', err.message));
@@ -247,6 +263,7 @@ async function run(args) {
         oldFormUuid,
         newFormUuid: null,
         name: formName,
+        formType,
         status: 'failed',
         error: err.message,
       });
@@ -262,6 +279,7 @@ async function run(args) {
         oldFormUuid,
         newFormUuid,
         name: formName,
+        formType,
         status: 'skipped',
         error: t('import.schema_empty_msg'),
       });
@@ -279,7 +297,7 @@ async function run(args) {
     );
 
     // 4.3 保存 Schema
-    const saveResult = await saveFormSchema(newAppType, newFormUuid, adaptedSchema, authRef);
+    const saveResult = await saveFormSchema(newAppType, newFormUuid, adaptedSchema, authRef, formType);
     if (!saveResult || !saveResult.success) {
       const errorMsg = saveResult ? saveResult.errorMsg || t('common.unknown_error') : t('common.request_failed');
       fail(t('import.save_schema_failed', errorMsg));
@@ -287,6 +305,7 @@ async function run(args) {
         oldFormUuid,
         newFormUuid,
         name: formName,
+        formType,
         status: 'failed',
         error: t('import.save_schema_failed', errorMsg),
       });
@@ -308,6 +327,7 @@ async function run(args) {
       oldFormUuid,
       newFormUuid,
       name: formName,
+      formType,
       status: 'success',
     });
     successCount++;
@@ -352,4 +372,12 @@ async function run(args) {
   );
 }
 
-module.exports = { run };
+module.exports = {
+  run,
+  __test__: {
+    normalizeImportFormType,
+    buildCreateFormPostData,
+    adaptSerialNumberFormulas,
+    extractSchemaContent,
+  },
+};

package/lib/app/page-compat.js

@@ -30,6 +30,37 @@ const SUPPORTED_REMOVABLE_IMPORTS = new Set([
 ]);
 
 const SUPPORTED_HOOKS = new Set(['useState', 'useEffect']);
+const REQUIRED_RUNTIME_EXPORTS = {
+  getCustomState: [
+    'export function getCustomState(key) {',
+    '  if (typeof _customState === "undefined") {',
+    '    return key ? undefined : {};',
+    '  }',
+    '  if (key) {',
+    '    return _customState[key];',
+    '  }',
+    '  return Object.assign({}, _customState);',
+    '}',
+  ].join('\n'),
+  setCustomState: [
+    'export function setCustomState(newState) {',
+    '  if (typeof _customState === "undefined") {',
+    '    return;',
+    '  }',
+    '  Object.keys(newState || {}).forEach(function(key) {',
+    '    _customState[key] = newState[key];',
+    '  });',
+    '  this.forceUpdate();',
+    '}',
+  ].join('\n'),
+  forceUpdate: [
+    'export function forceUpdate() {',
+    '  this.setState({ timestamp: new Date().getTime() });',
+    '}',
+  ].join('\n'),
+  didMount: 'export function didMount() {}',
+  didUnmount: 'export function didUnmount() {}',
+};
 
 function parseSource(sourceCode) {
   return parser.parse(sourceCode, PARSER_OPTIONS);
@@ -53,11 +84,21 @@ function hasYidaRenderExport(ast) {
   });
 }
 
+function sourceHasYidaRenderExport(sourceCode) {
+  return /export\s+function\s+renderJsx\s*\(/.test(sourceCode || '');
+}
+
 function isAuthoringPath(sourcePath) {
   return /\.oyd\.(jsx?|tsx?)$/i.test(sourcePath || '') ||
     /\.openyida\.(jsx?|tsx?)$/i.test(sourcePath || '');
 }
 
+function shouldBuildPageSource(sourceCode, sourcePath = '', options = {}) {
+  return options.modern === true ||
+    isAuthoringPath(sourcePath) ||
+    (!sourceHasYidaRenderExport(sourceCode) && /export\s+default\b/.test(sourceCode || ''));
+}
+
 function isSupportedRemovableImport(sourceValue) {
   return SUPPORTED_REMOVABLE_IMPORTS.has(String(sourceValue || '').toLowerCase());
 }
@@ -324,6 +365,73 @@ function removeSupportedImports(ast, fixes, errors) {
   });
 }
 
+function collectExportedFunctionNames(ast) {
+  const names = new Set();
+  ast.program.body.forEach((statement) => {
+    if (
+      statement.type === 'ExportNamedDeclaration' &&
+      statement.declaration &&
+      statement.declaration.type === 'FunctionDeclaration' &&
+      statement.declaration.id
+    ) {
+      names.add(statement.declaration.id.name);
+    }
+  });
+  return names;
+}
+
+function hasTopLevelCustomState(ast) {
+  return ast.program.body.some((statement) => {
+    return statement.type === 'VariableDeclaration' &&
+      statement.declarations.some((declarator) => {
+        return declarator.id &&
+          declarator.id.type === 'Identifier' &&
+          declarator.id.name === '_customState';
+      });
+  });
+}
+
+function ensureYidaRuntimeContract(sourceCode) {
+  const ast = parseSource(sourceCode);
+  const exportedNames = collectExportedFunctionNames(ast);
+  const fixes = [];
+  const prepend = [];
+  const append = [];
+  const needsStateHelper = !exportedNames.has('getCustomState') || !exportedNames.has('setCustomState');
+
+  if (needsStateHelper && !hasTopLevelCustomState(ast)) {
+    prepend.push('var _customState = {};');
+    fixes.push({
+      rule: 'runtime-custom-state',
+      message: 'Inserted default _customState store for Yida runtime helpers',
+    });
+  }
+
+  Object.keys(REQUIRED_RUNTIME_EXPORTS).forEach((name) => {
+    if (!exportedNames.has(name)) {
+      append.push(REQUIRED_RUNTIME_EXPORTS[name]);
+      fixes.push({
+        rule: 'runtime-export-' + name,
+        message: `Inserted missing export function ${name} for Yida runtime contract`,
+      });
+    }
+  });
+
+  if (prepend.length === 0 && append.length === 0) {
+    return { code: sourceCode, fixes };
+  }
+
+  return {
+    code: [
+      prepend.join('\n'),
+      sourceCode.trimEnd(),
+      append.join('\n\n'),
+      '',
+    ].filter(Boolean).join('\n\n'),
+    fixes,
+  };
+}
+
 function fixYidaSource(sourceCode) {
   const ast = parseSource(sourceCode);
   const fixes = [];
@@ -335,9 +443,11 @@ function fixYidaSource(sourceCode) {
   fixVariableDeclarations(ast, fixes);
   fixRenderTimestamp(ast, fixes);
 
+  const runtimeResult = ensureYidaRuntimeContract(generateCode(ast));
+
   return {
-    code: generateCode(ast),
-    fixes,
+    code: runtimeResult.code,
+    fixes: fixes.concat(runtimeResult.fixes),
     errors,
     mode: 'yida-source',
   };
@@ -529,6 +639,132 @@ function replaceStateSettersInStatement(statement, stateSetters) {
   return wrapper.program.body[0];
 }
 
+function addBindingNames(pattern, names) {
+  if (!pattern) {
+    return;
+  }
+  if (pattern.type === 'Identifier') {
+    names.add(pattern.name);
+    return;
+  }
+  if (pattern.type === 'ArrayPattern') {
+    pattern.elements.forEach(element => addBindingNames(element, names));
+    return;
+  }
+  if (pattern.type === 'ObjectPattern') {
+    pattern.properties.forEach((property) => {
+      addBindingNames(property.value || property.argument || property.key, names);
+    });
+    return;
+  }
+  if (pattern.type === 'RestElement') {
+    addBindingNames(pattern.argument, names);
+    return;
+  }
+  if (pattern.type === 'AssignmentPattern') {
+    addBindingNames(pattern.left, names);
+  }
+}
+
+function collectComponentBindingNames(componentBody) {
+  const names = new Set();
+  componentBody.forEach((statement) => {
+    if (statement.type === 'VariableDeclaration') {
+      statement.declarations.forEach(declarator => addBindingNames(declarator.id, names));
+    } else if ((statement.type === 'FunctionDeclaration' || statement.type === 'ClassDeclaration') && statement.id) {
+      names.add(statement.id.name);
+    }
+  });
+  return names;
+}
+
+function collectUseStateSetterNames(componentBody) {
+  const names = new Set();
+  componentBody.forEach((statement) => {
+    if (statement.type !== 'VariableDeclaration') {
+      return;
+    }
+    statement.declarations.forEach((declarator) => {
+      if (isUseStateDeclarator(declarator)) {
+        names.add(declarator.id.elements[1].name);
+      }
+    });
+  });
+  return names;
+}
+
+function collectReferencedIdentifiersFromStatements(statements) {
+  const names = new Set();
+  if (!statements || statements.length === 0) {
+    return names;
+  }
+  const wrapper = t.file(t.program(statements.map(statement => t.cloneNode(statement))));
+  traverse(wrapper, {
+    Identifier(pathRef) {
+      if (typeof pathRef.isReferencedIdentifier === 'function') {
+        if (!pathRef.isReferencedIdentifier()) {
+          return;
+        }
+      } else if (
+        pathRef.parent.type === 'MemberExpression' &&
+        pathRef.parent.property === pathRef.node &&
+        !pathRef.parent.computed
+      ) {
+        return;
+      }
+      names.add(pathRef.node.name);
+    },
+  });
+  return names;
+}
+
+function collectStatementBindingNames(statements) {
+  const names = new Set();
+  (statements || []).forEach((statement) => {
+    if (statement.type === 'VariableDeclaration') {
+      statement.declarations.forEach(declarator => addBindingNames(declarator.id, names));
+    } else if ((statement.type === 'FunctionDeclaration' || statement.type === 'ClassDeclaration') && statement.id) {
+      names.add(statement.id.name);
+    }
+  });
+  return names;
+}
+
+function addUnsupportedEffectLocalReferenceErrors(effect, componentBindings, allowedBindings, errors, reportedNames, line) {
+  const referencedNames = collectReferencedIdentifiersFromStatements(effect.mount.concat(effect.unmount));
+  referencedNames.forEach((name) => {
+    if (!componentBindings.has(name) || allowedBindings.has(name) || reportedNames.has(name)) {
+      return;
+    }
+    reportedNames.add(name);
+    errors.push({
+      code: 'UNSUPPORTED_EFFECT_LOCAL_REFERENCE',
+      message: `useEffect(..., []) references local component binding "${name}", which would be undefined inside Yida didMount/didUnmount. Move the logic inline, use a supported state setter functional update, or write native export function didMount().`,
+      line,
+    });
+  });
+}
+
+function addUnsupportedEffectCleanupReferenceErrors(effect, errors, reportedNames, line) {
+  const mountBindings = collectStatementBindingNames(effect.mount);
+  if (mountBindings.size === 0 || effect.unmount.length === 0) {
+    return;
+  }
+
+  const cleanupRefs = collectReferencedIdentifiersFromStatements(effect.unmount);
+  cleanupRefs.forEach((name) => {
+    if (!mountBindings.has(name) || reportedNames.has(name)) {
+      return;
+    }
+    reportedNames.add(name);
+    errors.push({
+      code: 'UNSUPPORTED_EFFECT_CLEANUP_REFERENCE',
+      message: `useEffect cleanup references effect-local binding "${name}", which would be undefined inside Yida didUnmount. Store it on this (for native didMount/didUnmount) or avoid cleanup-local captures in authoring mode.`,
+      line,
+    });
+  });
+}
+
 function statementContainsUseEffect(statement) {
   return statement.type === 'ExpressionStatement' &&
     statement.expression &&
@@ -539,6 +775,10 @@ function statementContainsUseEffect(statement) {
 function splitComponentBody(componentBody, errors) {
   const stateItems = [];
   const stateSetters = new Map();
+  const componentBindings = collectComponentBindingNames(componentBody);
+  const allowedEffectBindings = collectUseStateSetterNames(componentBody);
+  const reportedEffectRefs = new Set();
+  const reportedCleanupRefs = new Set();
   const renderStatements = [];
   const didMountStatements = [];
   const didUnmountStatements = [];
@@ -573,6 +813,20 @@ function splitComponentBody(componentBody, errors) {
     if (statementContainsUseEffect(statement)) {
       const effect = extractEffect(statement.expression, errors);
       if (effect) {
+        addUnsupportedEffectLocalReferenceErrors(
+          effect,
+          componentBindings,
+          allowedEffectBindings,
+          errors,
+          reportedEffectRefs,
+          statement.loc && statement.loc.start ? statement.loc.start.line : undefined
+        );
+        addUnsupportedEffectCleanupReferenceErrors(
+          effect,
+          errors,
+          reportedCleanupRefs,
+          statement.loc && statement.loc.start ? statement.loc.start.line : undefined
+        );
         didMountStatements.push(...effect.mount);
         didUnmountStatements.push(...effect.unmount);
       }
@@ -801,7 +1055,9 @@ function buildPageFile(sourcePath, options = {}) {
 module.exports = {
   buildPageSource,
   buildPageFile,
+  ensureYidaRuntimeContract,
   fixYidaSource,
   getCompatOutputPath,
   isAuthoringPath,
+  shouldBuildPageSource,
 };

package/lib/app/page-compiler.js

@@ -7,6 +7,7 @@ const { default: babelTransform } = require('../core/babel-transform');
 const { findProjectRoot } = require('../core/utils');
 const { t } = require('../core/i18n');
 const { info, success, error } = require('../core/chalk');
+const { ensureYidaRuntimeContract } = require('./page-compat');
 
 /**
  * 编译宜搭自定义页面 JSX/JS 源码。
@@ -20,7 +21,9 @@ function compileSource(sourcePath) {
   const compiledPath = path.join(findProjectRoot(), 'pages', 'dist', compiledFileName);
 
   info(t('publish.reading_source', sourceFileName));
-  const sourceCode = fs.readFileSync(sourcePath, 'utf-8');
+  const rawSourceCode = fs.readFileSync(sourcePath, 'utf-8');
+  const runtimeResult = ensureYidaRuntimeContract(rawSourceCode);
+  const sourceCode = runtimeResult.code;
 
   info(t('publish.compiling', sourceFileName));
   const babelResult = babelTransform(sourceCode, {}, false, { RE_VERSION: '7.4.0' });