@lcap/nasl 3.5.0-beta.1 → 3.5.0-beta.2

package/src/concepts/Logic__.ts

@@ -33,6 +33,7 @@ import type CallInterface from './CallInterface__';
 import type CallLogic from './CallLogic__';
 import { CUSTOM_CONNECTOR_EDITABLE_SUFFIX } from './basics/constants';
 import type Interface from './Interface__';
+import type BusinessComponent from './BusinessComponent__';
 
 //================================================================================
 // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
@@ -42,8 +43,8 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
-import * as Type from './utils/types';
-import * as Assert from './utils/asserts';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
 import BaseNode from '../common/BaseNode';
 import type Transactional from './Transactional__';
@@ -64,61 +65,54 @@ import type Process from './Process__';
  * 逻辑
  */
 @concept('逻辑')
-// @ts-ignore
 export class Logic extends BaseNode {
   /** 类名 */
-  static readonly ConceptName = 'Logic';
+  static readonly ConceptName: string = 'Logic';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['BaseNode'];
+  static readonly inheritanceChain: string[] = ['BaseNode'];
 
   /**
    * 产品概念
    */
   @property('concept')
   // @ts-ignore
-  readonly concept!: 'Logic' | 'AuthLogic' | 'AuthLogicForCallInterface';
+  readonly concept!: 'Logic' | 'AuthLogic' | 'AuthLogicForCallInterface' | 'BusinessLogic';
 
   /**
    * 逻辑名称
    */
   @property()
-  // @ts-ignore
   name!: string;
 
   /**
    * 逻辑标题
    */
   @property()
-  // @ts-ignore
   title!: string;
 
   /**
    * 逻辑描述
    */
   @property()
-  // @ts-ignore
   description!: string;
 
   /**
    * 触发方式
    */
   @property()
-  // @ts-ignore
   triggerType!: string;
 
   /**
    * 定时任务表达式
    */
   @property()
-  // @ts-ignore
   cron!: string;
 
   /**
    * 是否可覆写
    */
   @property()
-  // @ts-ignore
   overridable!: boolean;
 
   /**
@@ -127,7 +121,6 @@ export class Logic extends BaseNode {
   @property({
     objectRef: 'Transactional',
   })
-  // @ts-ignore
   transactional!: Transactional;
 
   /**
@@ -397,7 +390,7 @@ export class Logic extends BaseNode {
         this,
         'typeParams',
       );
-    } else if (Assert.isTypeParam(options)) {
+    } else if (asserts.isTypeParam(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       typeParam = options;
       Object.assign(typeParam, relationOptions);
@@ -547,7 +540,7 @@ export class Logic extends BaseNode {
         this,
         'params',
       );
-    } else if (Assert.isParam(options)) {
+    } else if (asserts.isParam(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       param = options;
       Object.assign(param, relationOptions);
@@ -697,7 +690,7 @@ export class Logic extends BaseNode {
         this,
         'returns',
       );
-    } else if (Assert.isReturn(options)) {
+    } else if (asserts.isReturn(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       ret = options;
       Object.assign(ret, relationOptions);
@@ -847,7 +840,7 @@ export class Logic extends BaseNode {
         this,
         'variables',
       );
-    } else if (Assert.isVariable(options)) {
+    } else if (asserts.isVariable(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       variable = options;
       Object.assign(variable, relationOptions);
@@ -968,7 +961,7 @@ export class Logic extends BaseNode {
     const relationOptions = { parentNode: this, parentKey: 'body' };
     const LogicItem = getConceptConstructor('LogicItem');
     let logicItem: LogicItem;
-    if (Assert.isLogicItem(options)) {
+    if (asserts.isLogicItem(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       logicItem = options;
       Object.assign(logicItem, relationOptions);
@@ -1069,7 +1062,7 @@ export class Logic extends BaseNode {
     const relationOptions = { parentNode: this, parentKey: 'playground' };
     const LogicItem = getConceptConstructor('LogicItem');
     let logicItem: LogicItem;
-    if (Assert.isLogicItem(options)) {
+    if (asserts.isLogicItem(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       logicItem = options;
       Object.assign(logicItem, relationOptions);
@@ -1553,15 +1546,15 @@ export class Logic extends BaseNode {
     if (Array.isArray(this.variables)) {
       varList.push(...this.variables);
     }
-    if (this.view) {
-      // 页面下，变量名不可以跟逻辑名相同，会有js 翻译问题
+    if (this.likeComponent) {
+      // 页面/业务组件下，变量名不可以跟逻辑名相同，会有js 翻译问题
       varList.push(this);
 
-      if (Array.isArray(this.view.params)) {
-        varList.push(...this.view.params);
+      if (Array.isArray(this.likeComponent.params)) {
+        varList.push(...this.likeComponent.params);
       }
-      if (Array.isArray(this.view.variables)) {
-        varList.push(...this.view.variables);
+      if (Array.isArray(this.likeComponent.variables)) {
+        varList.push(...this.likeComponent.variables);
       }
     }
 
@@ -1765,7 +1758,11 @@ export class Logic extends BaseNode {
           code += indent((state?.tabSize || 0) + 1);
           code += 'const __LogicEmpty: any = null;';
         }
-      } else if (self.body.length <= 2 && !Assert.isNamespace(self.parentNode) && !Assert.isProcess(self.parentNode)) {
+      } else if (
+        self.body.length <= 2 &&
+        !asserts.isNamespace(self.parentNode) &&
+        !asserts.isProcess(self.parentNode)
+      ) {
         code += indent((state?.tabSize || 0) + 1);
         code += `${indent(state?.tabSize || 0 + 4)}const __LogicEmpty: any = null;`;
       }
@@ -1809,11 +1806,11 @@ export class Logic extends BaseNode {
     const IDENTIFIERMAP = new Set<Variable | Return>();
 
     if (!prefix) {
-      code += `export function ${self.name}`;
+      code += `export function ${self.tsName}`;
     } else if (prefix === 'noExport') {
-      code += `function ${self.name}`;
+      code += `function ${self.tsName}`;
     } else if (prefix === 'inObject') {
-      code += `${self.name}`;
+      code += `${self.tsName}`;
     }
     if (self.typeParams?.length) {
       code += '<';
@@ -1839,8 +1836,8 @@ export class Logic extends BaseNode {
     const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
     // const needGetSourceMapOqlList: Promise<any>[] = [];
     yield* self.traverseChildrenGenerator(function* traverseChildrenGenerator(el) {
-      if (el && (Assert.isBatchAssignment(el) || (Assert.isAssignment(el) && el.left?.name))) {
-        if (Assert.isAssignment(el)) {
+      if (el && (asserts.isBatchAssignment(el) || (asserts.isAssignment(el) && el.left?.name))) {
+        if (asserts.isAssignment(el)) {
           const advanceVar = self.variables?.find(
             (variable) => !variable.typeAnnotation && el.left?.name === variable.name,
           );
@@ -1851,7 +1848,7 @@ export class Logic extends BaseNode {
           if (advanceRn && !advanceMap.get(advanceRn)) {
             advanceMap.set(advanceRn, el);
           }
-        } else if (Assert.isBatchAssignment(el)) {
+        } else if (asserts.isBatchAssignment(el)) {
           yield* wrapForEach(el.assignmentLines, function* warpForEachGenerator({ leftIndex }) {
             const leftCode =
               leftIndex.length === 1
@@ -1922,7 +1919,7 @@ export class Logic extends BaseNode {
       code += `${indent((state?.tabSize || 0) + 1)}// @ts-ignore\n`;
       code += `${indent((state?.tabSize || 0) + 1)}let `;
       code += yield* node.toEmbeddedTS(shiftState(state, code, { inline: true }));
-      if (Assert.isBatchAssignment(assignment)) {
+      if (asserts.isBatchAssignment(assignment)) {
         yield* wrapForEach(assignment.assignmentLines, function* warpForEachGenerator({ leftIndex, rightIndex }) {
           const leftCode =
             leftIndex.length === 1
@@ -1935,7 +1932,7 @@ export class Logic extends BaseNode {
                 ? assignment.rights[rightIndex[0]]?.expression
                 : assignment.rights[rightIndex[0]]?.members[rightIndex[1]];
             // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
-            if (rightNode?.typeAnnotation && !(Assert.isCallQueryComponent(rightNode) && !rightNode.isAutoInfer())) {
+            if (rightNode?.typeAnnotation && !(asserts.isCallQueryComponent(rightNode) && !rightNode.isAutoInfer())) {
               if (rightNode.concept === 'NewComposite' && rightNode.typeAnnotation?.typeKind === 'anonymousStructure') {
                 code += '= ';
                 code += (yield* rightNode.getInitCode(shiftState(state, code, { inline: true }))) || 'null';
@@ -1979,7 +1976,7 @@ export class Logic extends BaseNode {
       } else {
         const rightNode: any = assignment.right;
         // 当右边有明确类型时，直接使用其类型。旧版本数据查询不能直接使用其 typeAnnotation
-        if (rightNode?.typeAnnotation && !(Assert.isCallQueryComponent(rightNode) && !rightNode.isAutoInfer())) {
+        if (rightNode?.typeAnnotation && !(asserts.isCallQueryComponent(rightNode) && !rightNode.isAutoInfer())) {
           code += ': ';
           code += yield* rightNode.typeAnnotation?.toEmbeddedTS(shiftState(state, code, { inline: true })) ??
             returnOrigin('null');
@@ -1989,7 +1986,7 @@ export class Logic extends BaseNode {
           // 因为右侧枚举要赋值就得new 一下；
           if (
             rightNode &&
-            Assert.isIdentifier(rightNode) &&
+            asserts.isIdentifier(rightNode) &&
             rightNode.namespace &&
             rightNode.namespace.endsWith('enums')
           ) {
@@ -2018,7 +2015,7 @@ export class Logic extends BaseNode {
       code += `${indent((state?.tabSize || 0) + 1)}return ${this.returns[0].name};\n`;
     } else {
       // 如果长度小于2 并且不是虚拟节点就 加 报错，
-      if (self.body.length <= 2 && !Assert.isNamespace(self.parentNode)) {
+      if (self.body.length <= 2 && !asserts.isNamespace(self.parentNode)) {
         if (self.body.length && self.body[0].concept === 'JavaLogic') {
           code += '';
         } else {
@@ -2112,7 +2109,7 @@ ${indent(state.tabSize)} */\n`;
     // 需要类型推导的局部变量/返回值需要调整申明顺序
     const advanceMap: Map<Return | Variable, Assignment | BatchAssignment> = new Map();
     this.traverseChildren((el) => {
-      if (el && (Assert.isBatchAssignment(el) || (Assert.isAssignment(el) && el.left?.name))) {
+      if (el && (asserts.isBatchAssignment(el) || (asserts.isAssignment(el) && el.left?.name))) {
         const jsCode = el.toJS();
         const advanceVar = this.variables?.find(
           (variable) => !variable.typeAnnotation && jsCode.includes(`${variable.name} = `),
@@ -2179,10 +2176,10 @@ ${indent(state.tabSize)} */\n`;
 
   *getRightCode(code: string, assignment: Assignment | BatchAssignment, rightNode: any) {
     code = code.replaceAll('\n', ' ');
-    if (Assert.isAssignment(assignment) && !assignment.right) return code;
+    if (asserts.isAssignment(assignment) && !assignment.right) return code;
 
     // 调用接口，参数替换成 null
-    if (Assert.isCallInterface(rightNode)) {
+    if (asserts.isCallInterface(rightNode)) {
       const { _interface } = rightNode.getModuleInterface();
       return _interface
         ? `${rightNode.tsCalleeKey}(${(_interface as unknown as Interface).params.map(() => 'null').join(',')})`
@@ -2190,7 +2187,7 @@ ${indent(state.tabSize)} */\n`;
     }
 
     // 调用服务端逻辑，参数替换成 null
-    if (Assert.isCallLogic(rightNode) && rightNode.calleeNamespace === 'app.logics') {
+    if (asserts.isCallLogic(rightNode) && rightNode.calleeNamespace === 'app.logics') {
       const calleeName = rightNode?.calleeName;
       const calleeLogic = this.app.logics.find((l) => l.name === calleeName);
       return calleeLogic ? `app.logics.${calleeName}(${calleeLogic.params.map(() => 'null').join(',')})` : null;
@@ -2255,7 +2252,7 @@ ${indent(state.tabSize)} */\n`;
     if (code.includes(expressionTsCode)) {
       let typeCode = '';
       yield* wrapForEach(matchCase.patterns, function* wrapForEach(pattern, index) {
-        if (Assert.isTypeAnnotation(pattern)) {
+        if (asserts.isTypeAnnotation(pattern)) {
           if (index === 0) {
             typeCode += yield* pattern.toEmbeddedTS();
           } else {
@@ -2371,12 +2368,14 @@ ${indent(state.tabSize)} */\n`;
         _path = `/${this.connector.parentKey}/${this.connector.name}`;
       }
     }
-    if (Assert.isFrontendLibrary(this.parentNode)) {
+    if (asserts.isFrontendLibrary(this.parentNode)) {
       _path += `/frontends/${this.parentNode.type}`;
-    } else if (this.parentNode.concept === 'BindEvent' && this.parentNode?.parentNode.concept === 'Frontend') {
-      _path += `/frontends/${this.parentNode.parentNode.name}/bindEvents/${name}.ts`;
+    } else if (this.parentNode.concept === 'BindEvent' && this.getAncestor('Frontend')) {
+      _path += `/frontendTypes/${this.getAncestor('FrontendType')?.name}/frontends/${
+        this.getAncestor('Frontend')?.name
+      }/bindEvents/${name}.ts`;
     }
-    return `/embedded/${this.app.name}${_path}/logics/${name}.ts`;
+    return `/embedded/${this.getAncestor('App')?.name}${_path}/logics/${name}.ts`;
   }
 
   *toEmbeddedTSFile(): EmbeddedTSFileGenerator {
@@ -2425,7 +2424,7 @@ ${indent(state.tabSize)} */\n`;
     const set = new Set();
     utils.traverse(
       ({ node }) => {
-        if (Assert.isCallQueryComponent(node)) {
+        if (asserts.isCallQueryComponent(node)) {
           set.add(node);
         }
       },
@@ -2494,7 +2493,7 @@ ${indent(state.tabSize)} */\n`;
   }
 
   get pathName(): string {
-    if (this.view) {
+    if (this.likeComponent) {
       return this.getEventLogicName('chinese');
     }
 
@@ -2540,7 +2539,7 @@ ${indent(state.tabSize)} */\n`;
 
   // 获取bindEvent下的logic的名称
   getEventLogicName(type?: string) {
-    if (Assert.isBindEvent(this.parentNode)) {
+    if (asserts.isBindEvent(this.parentNode)) {
       if (type === 'chinese') {
         const bindEvent = this.parentNode;
         const bindChineseName = bindEvent.getPageViewEventChineseName();
@@ -2584,6 +2583,10 @@ ${indent(state.tabSize)} */\n`;
     return this.getAncestor('Integration');
   }
 
+  get likeComponent(): View | BusinessComponent {
+    return this.view || (this?.getAncestor('BusinessComponent') as BusinessComponent);
+  }
+
   //================================================================================
   // 从这里开始到结尾注释之间的代码由 NASL Workbench 自动生成，请不手动修改！
   // ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓   ↓

package/src/concepts/MatchCase__.ts

@@ -22,8 +22,8 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
-import * as Type from './utils/types';
-import * as Assert from './utils/asserts';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
 import LogicItem from './LogicItem__';
 import type TypeAnnotation from './TypeAnnotation__';
@@ -32,13 +32,12 @@ import type TypeAnnotation from './TypeAnnotation__';
  * 匹配分支
  */
 @concept('匹配分支')
-// @ts-ignore
 export class MatchCase extends LogicItem {
   /** 类名 */
-  static readonly ConceptName = 'MatchCase';
+  static readonly ConceptName: string = 'MatchCase';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['LogicItem', 'BaseNode'];
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -162,7 +161,7 @@ export class MatchCase extends LogicItem {
         this,
         'patterns',
       );
-    } else if (Assert.isLogicItem(options)) {
+    } else if (asserts.isLogicItem(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       logicItem = options;
       Object.assign(logicItem, relationOptions);
@@ -283,7 +282,7 @@ export class MatchCase extends LogicItem {
     const relationOptions = { parentNode: this, parentKey: 'body' };
     const LogicItem = getConceptConstructor('LogicItem');
     let logicItem: LogicItem;
-    if (Assert.isLogicItem(options)) {
+    if (asserts.isLogicItem(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       logicItem = options;
       Object.assign(logicItem, relationOptions);
@@ -419,7 +418,7 @@ export class MatchCase extends LogicItem {
         this,
         'patterns',
       );
-    } else if (Assert.isTypeAnnotation(options)) {
+    } else if (asserts.isTypeAnnotation(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       typeAnnotation = options;
       Object.assign(typeAnnotation, relationOptions);
@@ -664,10 +663,10 @@ export class MatchCase extends LogicItem {
             const { patterns } = caseItem || {};
             if (Array.isArray(patterns)) {
               patterns.forEach((pattern) => {
-                if (Assert.isTypeAnnotation(pattern)) {
+                if (asserts.isTypeAnnotation(pattern)) {
                   const patternTypeKey = pattern.typeKey;
                   map[patternTypeKey] = true;
-                } else if (Assert.isMemberExpression(pattern) || Assert.isBooleanLiteral(pattern)) {
+                } else if (asserts.isMemberExpression(pattern) || asserts.isBooleanLiteral(pattern)) {
                   const patternValue = pattern.getValue();
                   map[patternValue] = true;
                 }
@@ -750,7 +749,7 @@ export class MatchCase extends LogicItem {
     if (Array.isArray(this.patterns)) {
       const patternStrArr = this.patterns.map((pattern) => {
         let patternStr = '';
-        if (Assert.isTypeAnnotation(pattern)) {
+        if (asserts.isTypeAnnotation(pattern)) {
           patternStr += `this.$isInstanceOf(${expression.toJS?.()}, '${pattern.sortedTypeKey}')`;
         } else {
           patternStr += `this.$global.isEqual(${expression.toJS?.()}, ${pattern.toJS?.()})`;
@@ -799,7 +798,7 @@ export class MatchCase extends LogicItem {
         if (Array.isArray(self.patterns) && self.patterns.length) {
           yield* wrapForEach(self.patterns, function* warpForEachGenerator(pattern, index) {
             // nasl.code.isUnionType<typeof ccc, List<Integer> | List<Boolean>>
-            if (Assert.isTypeAnnotation(pattern)) {
+            if (asserts.isTypeAnnotation(pattern)) {
               if (index === 0) {
                 code += `nasl.core.isUnionType<typeof `;
                 code += `${parentCode},`;
@@ -895,7 +894,7 @@ export class MatchCase extends LogicItem {
         if (Array.isArray(this.patterns) && this.patterns.length) {
           this.patterns.forEach((pattern, index) => {
             // nasl.code.isUnionType<typeof ccc, List<Integer> | List<Boolean>>
-            if (Assert.isTypeAnnotation(pattern)) {
+            if (asserts.isTypeAnnotation(pattern)) {
               if (index === 0) {
                 code += `nasl.core.isUnionType<typeof `;
                 code += `${parentCode},`;

package/src/concepts/Match__.ts

@@ -27,8 +27,8 @@ import { EventPayload, Params } from '../common/EventEmitter';
 import { concept, excludedInJSON, property, getConceptConstructor, getBaseNode } from '../decorators';
 
 import * as utils from '../utils';
-import * as Type from './utils/types';
-import * as Assert from './utils/asserts';
+import * as types from './utils/types';
+import * as asserts from './utils/asserts';
 import { v4 as uuidv4 } from 'uuid';
 import LogicItem from './LogicItem__';
 import type MatchCase from './MatchCase__';
@@ -37,13 +37,12 @@ import type MatchCase from './MatchCase__';
  * 匹配
  */
 @concept('匹配')
-// @ts-ignore
 export class Match extends LogicItem {
   /** 类名 */
-  static readonly ConceptName = 'Match';
+  static readonly ConceptName: string = 'Match';
 
   /** 继承链 */
-  static readonly inheritanceChain = ['LogicItem', 'BaseNode'];
+  static readonly inheritanceChain: string[] = ['LogicItem', 'BaseNode'];
 
   /**
    * 产品概念
@@ -58,7 +57,6 @@ export class Match extends LogicItem {
   @property({
     objectRef: 'LogicItem',
   })
-  // @ts-ignore
   expression!: LogicItem;
 
   /**
@@ -109,7 +107,7 @@ export class Match extends LogicItem {
     const relationOptions = { parentNode: this, parentKey: 'cases' };
     const MatchCase = getConceptConstructor('MatchCase');
     let matchCase: MatchCase;
-    if (Assert.isMatchCase(options)) {
+    if (asserts.isMatchCase(options)) {
       options.ensureDelete(); // 同一实例不支持多处存在
       matchCase = options;
       Object.assign(matchCase, relationOptions);
@@ -285,10 +283,10 @@ export class Match extends LogicItem {
           const { patterns } = caseItem || {};
           if (Array.isArray(patterns)) {
             patterns.forEach((pattern) => {
-              if (Assert.isTypeAnnotation(pattern)) {
+              if (asserts.isTypeAnnotation(pattern)) {
                 const patternTypeKey = pattern.typeKey;
                 map[patternTypeKey] = true;
-              } else if (Assert.isMemberExpression(pattern) || Assert.isBooleanLiteral(pattern)) {
+              } else if (asserts.isMemberExpression(pattern) || asserts.isBooleanLiteral(pattern)) {
                 const patternValue = pattern.getValue();
                 map[patternValue] = true;
               }
@@ -317,7 +315,7 @@ export class Match extends LogicItem {
     if (typeKind === 'union' && Array.isArray(typeArguments)) {
       return typeArguments.map((typeArg) => {
         let typeArgJson: any = typeArg;
-        if (Assert.isTypeAnnotation(typeArg)) {
+        if (asserts.isTypeAnnotation(typeArg)) {
           typeArgJson = typeArg.toJSON();
         }
         return new TypeAnnotation(typeArgJson);
@@ -742,7 +740,7 @@ export class Match extends LogicItem {
     if (self.expression) {
       code += indent(state?.tabSize || 0);
       // Identifier会使用自己本身的类型，来推导，因为右侧放的内容关系关系到内部类型推断
-      if (Assert.isIdentifier(self.expression) || Assert.isMemberExpression(self.expression)) {
+      if (asserts.isIdentifier(self.expression) || asserts.isMemberExpression(self.expression)) {
         code += parentCode = yield* self.expression.toEmbeddedTS(shiftState(state, code));
       } else {
         parentCode = '__matchExpression';
@@ -798,7 +796,7 @@ export class Match extends LogicItem {
     if (this.expression) {
       code += indent((state?.tabSize || 0) + 1);
       // Identifier会使用自己本身的类型，来推导，因为右侧放的内容关系关系到内部类型推断
-      if (Assert.isIdentifier(this.expression) || Assert.isMemberExpression(this.expression)) {
+      if (asserts.isIdentifier(this.expression) || asserts.isMemberExpression(this.expression)) {
         parentCode = this.expression?.toNaturalTS(shiftState(state, code, { inline: true }));
       } else {
         parentCode = '_value';