@nocobase/client-v2 2.1.0-beta.42 → 2.1.0-beta.43

package/src/components/form/__tests__/TypedVariableInput.test.tsx

@@ -0,0 +1,152 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { FlowContext, FlowContextProvider } from '@nocobase/flow-engine';
+import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import React from 'react';
+import { describe, expect, it, vi } from 'vitest';
+import { TypedVariableInput } from '../TypedVariableInput';
+
+function createContextWithEnv() {
+  const ctx = new FlowContext();
+  (ctx as any).t = (key: string) => key;
+
+  ctx.defineProperty('$env', {
+    value: { SMTP_PORT: 465, SECURE_FLAG: true },
+    meta: {
+      title: 'Env',
+      type: 'object',
+      properties: {
+        SMTP_PORT: { title: 'SMTP Port', type: 'number' },
+        SECURE_FLAG: { title: 'Secure flag', type: 'boolean' },
+      },
+    },
+  });
+
+  return ctx;
+}
+
+function renderWithCtx(ctx: FlowContext, node: React.ReactNode) {
+  return render(<FlowContextProvider context={ctx}>{node}</FlowContextProvider>);
+}
+
+describe('TypedVariableInput - constant rendering', () => {
+  it('renders an InputNumber for a numeric value when types=[number]', async () => {
+    const ctx = createContextWithEnv();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput
+        value={465}
+        types={[['number', { min: 1, max: 65535 }]]}
+        namespaces={['$env']}
+        onChange={() => undefined}
+      />,
+    );
+    const numberInput = await screen.findByDisplayValue('465');
+    expect(numberInput).toBeInTheDocument();
+    expect(numberInput.getAttribute('role')).toBe('spinbutton');
+  });
+
+  it('renders a boolean Select when value is true and types=[boolean]', async () => {
+    const ctx = createContextWithEnv();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput value={true} types={['boolean']} namespaces={['$env']} onChange={() => undefined} />,
+    );
+    await waitFor(() => {
+      // antd Select renders the chosen item label via a selection-item span
+      const item = screen.getByText('True');
+      expect(item).toBeInTheDocument();
+    });
+  });
+
+  it('renders the Null placeholder when value=null and nullable=true', async () => {
+    const ctx = createContextWithEnv();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput value={null} types={['number']} namespaces={['$env']} nullable onChange={() => undefined} />,
+    );
+    // Uses placeholder slot (not value) so antd's grey placeholder colour
+    // applies — see comment in TypedVariableInput.tsx.
+    const nullInput = await screen.findByPlaceholderText('<Null>');
+    expect(nullInput).toBeInTheDocument();
+    expect(nullInput.getAttribute('readonly')).not.toBeNull();
+  });
+});
+
+describe('TypedVariableInput - variable rendering', () => {
+  it('renders a labelled pill when value is a {{ $env.X }} expression', async () => {
+    const ctx = createContextWithEnv();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput
+        value="{{$env.SMTP_PORT}}"
+        types={['number']}
+        namespaces={['$env']}
+        onChange={() => undefined}
+      />,
+    );
+    await waitFor(() => {
+      const tag = screen.getByRole('button', { name: 'variable-tag' });
+      expect(tag.textContent).toContain('Env');
+      expect(tag.textContent).toContain('SMTP Port');
+    });
+  });
+
+  it('clears back to null when the close button is clicked (nullable=true)', async () => {
+    const ctx = createContextWithEnv();
+    const handleChange = vi.fn();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput
+        value="{{$env.SMTP_PORT}}"
+        types={['number']}
+        namespaces={['$env']}
+        nullable
+        onChange={handleChange}
+      />,
+    );
+    const clear = await screen.findByRole('button', { name: 'icon-close' });
+    fireEvent.click(clear);
+    expect(handleChange).toHaveBeenCalledWith(null);
+  });
+
+  it('clears back to default-of-first-type when nullable=false', async () => {
+    const ctx = createContextWithEnv();
+    const handleChange = vi.fn();
+    renderWithCtx(
+      ctx,
+      <TypedVariableInput
+        value="{{$env.SMTP_PORT}}"
+        types={['number']}
+        namespaces={['$env']}
+        nullable={false}
+        onChange={handleChange}
+      />,
+    );
+    const clear = await screen.findByRole('button', { name: 'icon-close' });
+    fireEvent.click(clear);
+    expect(handleChange).toHaveBeenCalledWith(0);
+  });
+});
+
+describe('TypedVariableInput - editor onChange propagation', () => {
+  it('forwards numeric edits via onChange', async () => {
+    const ctx = createContextWithEnv();
+    const handleChange = vi.fn();
+    renderWithCtx(ctx, <TypedVariableInput value={465} types={['number']} onChange={handleChange} />);
+    const numberInput = await screen.findByDisplayValue('465');
+    fireEvent.change(numberInput, { target: { value: '587' } });
+    // antd InputNumber may emit on blur; force blur to flush
+    fireEvent.blur(numberInput);
+    expect(handleChange).toHaveBeenCalled();
+    const lastCall = handleChange.mock.calls[handleChange.mock.calls.length - 1][0];
+    expect(lastCall).toBe(587);
+  });
+});

package/src/components/form/index.tsx

@@ -16,4 +16,5 @@ export * from './FileSizeInput';
 export * from './JsonTextArea';
 export * from './PasswordInput';
 export * from './RemoteSelect';
+export * from './TypedVariableInput';
 export * from './VariableInput';

package/src/flow/actions/__tests__/linkageRules.hiddenSync.restore.test.ts

@@ -0,0 +1,100 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+import { describe, expect, it, vi } from 'vitest';
+import { actionLinkageRules } from '../linkageRules';
+
+function createRule(actions: any[]) {
+  return {
+    key: 'r1',
+    title: 'r1',
+    enable: true,
+    condition: { logic: '$and', items: [] },
+    actions,
+  };
+}
+
+describe('linkageRules hidden state propagation', () => {
+  it('restores hidden state to same-target models when reverting to original props', async () => {
+    const blockModel = { uid: 'block-1' };
+
+    const hostModel: any = {
+      uid: 'host',
+      hidden: false,
+      context: { blockModel },
+      __allModels: [],
+      setProps: vi.fn(),
+      getFlow: vi.fn(() => ({})),
+      getStepParams: vi.fn((_flowKey: string, stepKey: string) => {
+        if (stepKey === 'init') return { fieldPath: 'org_m2o' };
+        return undefined;
+      }),
+      translate: (s: string) => s,
+    };
+
+    const sameTargetModel: any = {
+      uid: 'same-target',
+      hidden: false,
+      context: { blockModel },
+      setProps: vi.fn(),
+      getStepParams: vi.fn((_flowKey: string, stepKey: string) => {
+        if (stepKey === 'init') return { fieldPath: 'org_m2o' };
+        return undefined;
+      }),
+      translate: (s: string) => s,
+    };
+
+    const engine = {
+      forEachModel: (visitor: (m: any) => void) => {
+        [hostModel, sameTargetModel].forEach(visitor);
+      },
+    };
+
+    const ctx: any = {
+      flowKey: 'buttonSettings',
+      model: hostModel,
+      engine,
+      app: {
+        jsonLogic: {
+          apply: vi.fn(() => true),
+        },
+      },
+      resolveJsonTemplate: vi.fn(async (value: any) => value),
+      getAction: (name: string) => {
+        if (name !== 'linkageSetActionProps') return undefined;
+        return {
+          handler: async (_ctx: any, params: any) => {
+            params.setProps(hostModel, {
+              hiddenModel: params.value === 'hidden',
+              disabled: false,
+              hiddenText: false,
+            });
+          },
+        };
+      },
+    };
+
+    await actionLinkageRules.handler(ctx, {
+      value: [
+        createRule([
+          {
+            name: 'linkageSetActionProps',
+            params: { value: 'hidden' },
+          },
+        ]),
+      ],
+    });
+    expect(hostModel.hidden).toBe(true);
+    expect(sameTargetModel.hidden).toBe(true);
+
+    await actionLinkageRules.handler(ctx, { value: [] });
+    expect(hostModel.hidden).toBe(false);
+    expect(sameTargetModel.hidden).toBe(false);
+  });
+});

package/src/flow/actions/__tests__/linkageRulesRefresh.test.ts

@@ -46,7 +46,7 @@ describe('linkageRulesRefresh action', () => {
     expect(handler).not.toHaveBeenCalled();
   });
 
-  it('runs linkage action on master model when forks are not mounted in runtime mode', async () => {
+  it('skips master model when forks can handle flow even if regular action buttons do not attach refs', async () => {
     const handler = vi.fn(async () => {});
     const model: any = {
       isFork: false,
@@ -74,6 +74,28 @@ describe('linkageRulesRefresh action', () => {
       flowKey: 'buttonSettings',
     });
 
+    expect(handler).not.toHaveBeenCalled();
+  });
+
+  it('runs linkage action on master model when no forks exist in runtime mode', async () => {
+    const handler = vi.fn(async () => {});
+    const model: any = {
+      isFork: false,
+      forks: new Set(),
+      getFlow: vi.fn(() => ({})),
+      getStepParams: vi.fn(() => ({ value: ['master-runtime'] })),
+    };
+    const ctx: any = {
+      model,
+      resolveJsonTemplate: vi.fn(async (p: any) => p),
+      getAction: vi.fn(() => ({ handler })),
+    };
+
+    await linkageRulesRefresh.handler(ctx, {
+      actionName: 'actionLinkageRules',
+      flowKey: 'buttonSettings',
+    });
+
     expect(handler).toHaveBeenCalledWith(ctx, { value: ['master-runtime'] });
   });
 

package/src/flow/actions/linkageRules.tsx

@@ -2099,16 +2099,17 @@ const commonLinkageRulesHandler = async (ctx: FlowContext, params: any) => {
   mergedByUid.forEach((model: any, uid) => {
     const patchProps = mergedPropsByUid.get(uid) || {};
     const newProps = { ...model.__originalProps, ...patchProps };
-    const hasHiddenModelPatch = Object.prototype.hasOwnProperty.call(patchProps, 'hiddenModel');
+    const prevHidden = !!model.hidden;
+    const nextHidden = !!newProps.hiddenModel;
 
     model.setProps(_.omit(newProps, ['hiddenModel', 'value', 'hiddenText']));
     syncFieldOptionsToForks(model, patchProps);
     if (typeof model.setHidden === 'function') {
       model.setHidden(!!newProps.hiddenModel);
     } else {
-      model.hidden = !!newProps.hiddenModel;
-      if (hasHiddenModelPatch) {
-        hiddenStatePatches.push({ model, hidden: model.hidden });
+      model.hidden = nextHidden;
+      if (prevHidden !== nextHidden) {
+        hiddenStatePatches.push({ model, hidden: nextHidden });
       }
     }
 

package/src/flow/actions/linkageRulesRefresh.tsx

@@ -41,16 +41,15 @@ export const linkageRulesRefresh = defineAction({
     const flowSettingsEnabled = Boolean(
       (ctx as any)?.flowSettingsEnabled || (model as any)?.context?.flowSettingsEnabled,
     );
-    const hasMountedForkWithFlow =
+    const hasForkWithFlow =
       !model?.isFork &&
       !!model?.forks?.size &&
       Array.from(model?.forks || []).some((fork: any) => {
         if (!fork || fork.disposed) return false;
-        if (!fork?.context?.ref?.current) return false;
         return !!fork?.getFlow?.(flowKey);
       });
     const isMasterMounted = Boolean((model as any)?.context?.ref?.current);
-    if (hasMountedForkWithFlow && !isMasterMounted && !flowSettingsEnabled) {
+    if (hasForkWithFlow && !isMasterMounted && !flowSettingsEnabled) {
       return;
     }
 

package/src/flow/components/code-editor/__tests__/runjsCompletions.test.ts

@@ -11,44 +11,97 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 
 // Mock engine api provider
 vi.mock('@nocobase/flow-engine', () => {
-  const doc = {
-    properties: {
-      foo: 'foo prop',
-      api: {
-        description: 'api client',
-        completion: { insertText: 'ctx.api' },
-        properties: {
-          request: {
-            description: 'send request',
-            completion: { insertText: "await ctx.api.request({ url: '', method: 'get' })" },
+  const baseDocProperties = {
+    foo: 'foo prop',
+    api: {
+      description: 'api client',
+      completion: { insertText: 'ctx.api' },
+      properties: {
+        request: {
+          description: 'send request',
+          completion: { insertText: "await ctx.api.request({ url: '', method: 'get' })" },
+        },
+      },
+    },
+    viewer: {
+      description: 'viewer helpers',
+      properties: {
+        popover: {
+          type: 'function',
+          description: 'open popover',
+          completion: {
+            insertText: 'await ctx.viewer.popover({ target: ctx.element?.__el, content: <div /> })',
+            requires: ['element'],
+          },
+        },
+        embed: {
+          type: 'function',
+          description: 'open embed',
+          completion: {
+            insertText: 'await ctx.viewer.embed({ target: ctx.element?.__el, content: <div /> })',
+            requires: ['element'],
           },
         },
       },
-      popup: {
-        description: 'popup context (async)',
-        detail: 'Promise<any>',
-        hidden: async (ctx: any) => !(await ctx?.popup)?.uid,
-        properties: {
-          uid: 'popup uid',
-          record: 'popup record',
-          parent: {
-            properties: {
-              record: 'parent record',
-            },
+    },
+    popup: {
+      description: 'popup context (async)',
+      detail: 'Promise<any>',
+      hidden: async (ctx: any) => !(await ctx?.popup)?.uid,
+      properties: {
+        uid: 'popup uid',
+        record: 'popup record',
+        parent: {
+          properties: {
+            record: 'parent record',
           },
         },
       },
     },
-    methods: {
-      bar: {
-        description: 'bar method',
-        completion: { insertText: "ctx.bar('value')" },
+  };
+  const methods = {
+    bar: {
+      description: 'bar method',
+      completion: { insertText: "ctx.bar('value')" },
+    },
+    render: {
+      description: 'render react content',
+      completion: { insertText: 'ctx.render(<div />)', requires: ['element'] },
+    },
+  };
+  const baseDoc = {
+    properties: baseDocProperties,
+    methods,
+  };
+  const domDoc = {
+    properties: {
+      ...baseDocProperties,
+      element: {
+        description: 'DOM container',
+        detail: 'ElementProxy',
+        properties: {
+          innerHTML: 'inner html',
+          setAttribute: {
+            type: 'function',
+            detail: '(name: string, value: string) => void',
+            completion: { insertText: "ctx.element.setAttribute('data-key', 'value')" },
+          },
+        },
       },
     },
+    methods,
   };
+  const domModels = new Set([
+    'JSBlockModel',
+    'JSFieldModel',
+    'JSEditableFieldModel',
+    'JSItemModel',
+    'JSColumnModel',
+    'FormJSFieldItemModel',
+  ]);
   return {
-    getRunJSDocFor: () => doc,
-    FlowRunJSContext: { getDoc: () => doc },
+    getRunJSDocFor: (ctx: any) => (domModels.has(ctx?.model?.constructor?.name) ? domDoc : baseDoc),
+    FlowRunJSContext: { getDoc: () => baseDoc },
     // New cohesive APIs
     listSnippetsForContext: async () => [
       {
@@ -69,6 +122,17 @@ vi.mock('@nocobase/flow-engine', () => {
 import { buildRunJSCompletions } from '../runjsCompletions';
 
 describe('buildRunJSCompletions', () => {
+  const labelsOf = (completions: any[]) => new Set(completions.map((c: any) => c.label));
+
+  const appliedTextsOf = (completions: any[]) =>
+    completions.flatMap((completion: any) => {
+      const mockView = { dispatch: vi.fn() } as any;
+      if (typeof completion.apply === 'function') {
+        completion.apply(mockView, completion, 0, 0);
+      }
+      return mockView.dispatch.mock.calls.map((call: any[]) => String(call[0]?.changes?.insert || ''));
+    });
+
   it('builds ctx property/method completions and snippets', async () => {
     const hostCtx = { popup: Promise.resolve({ uid: 'p1' }) }; // not used since engine doc is mocked
     const { completions, entries } = await buildRunJSCompletions(hostCtx, 'v1', 'block');
@@ -242,4 +306,185 @@ describe('buildRunJSCompletions', () => {
     // restore
     engineDoc.properties.popup.hidden = prev;
   });
+
+  it('adds safe browser/runtime global completions and excludes blocked globals', async () => {
+    const { completions } = await buildRunJSCompletions({}, 'v1', 'block');
+    const labels = new Set(completions.map((c: any) => c.label));
+
+    expect(labels.has('window.location.reload()')).toBe(true);
+    expect(labels.has('document.createElement()')).toBe(true);
+    expect(labels.has('navigator.clipboard.writeText()')).toBe(true);
+    expect(labels.has('console.log()')).toBe(true);
+    expect(labels.has('setTimeout()')).toBe(true);
+    expect(labels.has('Blob')).toBe(true);
+    expect(labels.has('URL')).toBe(true);
+
+    expect(labels.has('navigator.userAgent')).toBe(false);
+    expect(labels.has('navigator.geolocation')).toBe(false);
+    expect(labels.has('document.cookie')).toBe(false);
+    expect(labels.has('document.body')).toBe(false);
+    expect(labels.has('document.getElementById()')).toBe(false);
+    expect(labels.has('window.location.href')).toBe(false);
+    expect(labels.has('window.location.href =')).toBe(true);
+  });
+
+  it('adds stable ctx runtime namespace completions', async () => {
+    const hostCtx = {
+      model: {
+        constructor: {
+          name: 'JSBlockModel',
+        },
+      },
+    };
+    const { completions } = await buildRunJSCompletions(hostCtx, 'v1', 'block');
+    const labels = labelsOf(completions);
+
+    expect(labels.has('ctx.runjs()')).toBe(true);
+    expect(labels.has('ctx.sql.run()')).toBe(true);
+    expect(labels.has('ctx.logger.info()')).toBe(true);
+    expect(labels.has('ctx.element.setAttribute()')).toBe(true);
+    expect(labels.has('ctx.libs.React.createElement()')).toBe(true);
+    expect(labels.has('ctx.libs.lodash.get()')).toBe(true);
+  });
+
+  it('does not expose ctx.element for generic base completions', async () => {
+    const { completions } = await buildRunJSCompletions({}, 'v1', 'block');
+    const labels = labelsOf(completions);
+    const appliedTexts = appliedTextsOf(completions);
+
+    expect([...labels].some((label) => String(label).startsWith('ctx.element'))).toBe(false);
+    expect(labels.has('ctx.render()')).toBe(false);
+    expect(appliedTexts.some((text) => /\bctx\.element\b/.test(text))).toBe(false);
+    expect(appliedTexts.some((text) => text === 'ctx.render(<div />)')).toBe(false);
+  });
+
+  it('keeps ctx.element completions for DOM container models', async () => {
+    const hostCtx = {
+      model: {
+        constructor: {
+          name: 'JSBlockModel',
+        },
+      },
+    };
+    const { completions } = await buildRunJSCompletions(hostCtx, 'v1', 'block');
+    const labels = labelsOf(completions);
+
+    expect(labels.has('ctx.element.innerHTML')).toBe(true);
+    expect(labels.has('ctx.element.setAttribute()')).toBe(true);
+    expect(labels.has('ctx.libs.ReactDOM.createRoot()')).toBe(true);
+    expect(labels.has('ctx.render()')).toBe(true);
+
+    const renderCompletion = completions.find((c: any) => c.label === 'ctx.render()');
+    const mockView = { dispatch: vi.fn() } as any;
+    (renderCompletion as any).apply?.(mockView, renderCompletion, 0, 0);
+    expect(mockView.dispatch.mock.calls[0][0]?.changes?.insert).toBe('ctx.render(<div />)');
+  });
+
+  it('hides ctx.element-dependent completions for eventFlow', async () => {
+    const hostCtx = {
+      model: {
+        constructor: {
+          name: 'JSBlockModel',
+        },
+      },
+    };
+    const { completions } = await buildRunJSCompletions(hostCtx, 'v1', 'eventFlow');
+    const labels = labelsOf(completions);
+    const appliedTexts = appliedTextsOf(completions);
+
+    expect([...labels].some((label) => String(label).startsWith('ctx.element'))).toBe(false);
+    expect(labels.has('ctx.libs.ReactDOM.createRoot()')).toBe(false);
+    expect(labels.has('ctx.ReactDOM.createRoot()')).toBe(false);
+    expect(labels.has('ctx.viewer.popover()')).toBe(false);
+    expect(labels.has('ctx.viewer.embed()')).toBe(false);
+    expect(labels.has('ctx.render()')).toBe(false);
+    expect(appliedTexts.some((text) => /\bctx\.element\b/.test(text))).toBe(false);
+    expect(appliedTexts.some((text) => text === 'ctx.render(<div />)')).toBe(false);
+  });
+
+  it('hides ctx.element-dependent completions for non-DOM action models', async () => {
+    for (const [modelName, scene] of [
+      ['JSRecordActionModel', 'table'],
+      ['JSFormActionModel', 'form'],
+      ['FilterFormJSActionModel', 'form'],
+    ]) {
+      const hostCtx = {
+        model: {
+          constructor: {
+            name: modelName,
+          },
+        },
+      };
+      const { completions } = await buildRunJSCompletions(hostCtx, 'v1', scene);
+      const labels = labelsOf(completions);
+      const appliedTexts = appliedTextsOf(completions);
+
+      expect([...labels].some((label) => String(label).startsWith('ctx.element'))).toBe(false);
+      expect(labels.has('ctx.libs.ReactDOM.createRoot()')).toBe(false);
+      expect(labels.has('ctx.ReactDOM.createRoot()')).toBe(false);
+      expect(labels.has('ctx.render()')).toBe(false);
+      expect(appliedTexts.some((text) => /\bctx\.element\b/.test(text))).toBe(false);
+      expect(appliedTexts.some((text) => text === 'ctx.render(<div />)')).toBe(false);
+    }
+  });
+
+  it('uses friendly insertText for ctx.loadCSS and ctx.previewRunJS', async () => {
+    const { completions } = await buildRunJSCompletions({}, 'v1', 'block');
+
+    for (const [label, expected] of [
+      ['ctx.loadCSS()', "await ctx.loadCSS('https://example.com/style.css')"],
+      ['ctx.previewRunJS()', "await ctx.previewRunJS('console.log(1)', 'v2')"],
+      ['ctx.resolveJsonTemplate()', "await ctx.resolveJsonTemplate({ value: '{{ctx.record.id}}' })"],
+    ]) {
+      const completion = completions.find((c: any) => c.label === label);
+      expect(completion).toBeTruthy();
+      expect(typeof (completion as any).apply).toBe('function');
+
+      const mockView = { dispatch: vi.fn() } as any;
+      (completion as any).apply?.(mockView, completion, 0, 0);
+      expect(mockView.dispatch.mock.calls[0][0]?.changes?.insert).toBe(expected);
+      expect(mockView.dispatch.mock.calls[0][0]?.changes?.insert).not.toBe(label);
+    }
+  });
+
+  it('requests completion metadata from ctx.getApiInfos() for editor completions', async () => {
+    const getApiInfos = vi.fn(async (options?: any) => ({
+      customRuntime: {
+        type: 'function',
+        description: 'custom runtime helper',
+        completion: {
+          insertText: options?.includeCompletion ? "await ctx.customRuntime('value')" : undefined,
+        },
+      },
+    }));
+
+    const { completions } = await buildRunJSCompletions({ getApiInfos }, 'v1', 'block');
+
+    expect(getApiInfos).toHaveBeenCalledWith({ version: 'v1', includeCompletion: true });
+    const completion = completions.find((c: any) => c.label === 'ctx.customRuntime()');
+    expect(completion).toBeTruthy();
+
+    const mockView = { dispatch: vi.fn() } as any;
+    (completion as any).apply?.(mockView, completion, 0, 0);
+    expect(mockView.dispatch.mock.calls[0][0]?.changes?.insert).toBe("await ctx.customRuntime('value')");
+  });
+
+  it('keeps friendly insertText for ctx.resolveJsonTemplate with Chinese docs', async () => {
+    const hostCtx = {
+      api: {
+        auth: {
+          locale: 'zh-CN',
+        },
+      },
+    };
+    const { completions } = await buildRunJSCompletions(hostCtx, 'v1', 'block');
+    const completion = completions.find((c: any) => c.label === 'ctx.resolveJsonTemplate()');
+    expect(completion).toBeTruthy();
+
+    const mockView = { dispatch: vi.fn() } as any;
+    (completion as any).apply?.(mockView, completion, 0, 0);
+    expect(mockView.dispatch.mock.calls[0][0]?.changes?.insert).toBe(
+      "await ctx.resolveJsonTemplate({ value: '{{ctx.record.id}}' })",
+    );
+  });
 });