Skip to content
| Marketplace
Sign in
Visual Studio Code>Other>SyteLine IDS Form DesignerNew to Visual Studio Code? Get it now.
SyteLine IDS Form Designer

SyteLine IDS Form Designer

Jeking

|
42 installs
| (0) | Free
Visual form builder for SyteLine IDS forms (*.ids.json, *.iv2.json): layout tree, preview canvas, properties, events, variables and script.
Installation
Launch VS Code Quick Open (Ctrl+P), paste the following command, and press enter.
Copied to clipboard
More Info

SyteLine IDS Form Designer

A VS Code custom editor that opens SyteLine IDS form JSON files (*.ids.json) in a visual designer instead of raw text.

Features

  • Custom editor on **/*.ids.json — opens forms visually, with an "Open as JSON" button to fall back to text.
  • Form tab — edit form metadata (name, caption, template, primary IDO, datasource, initial command, filter form spec); Template offers standard IDS template suggestions while remaining editable for custom values; toggle primary_standardoperations.
  • Layout tab with three views — Tree, Preview, and Split:
    • Container tree reassembled from the flat layout.notebooks / sections / components arrays (containment is by container name reference). Grid columns nest under their grid; template panes (##…) and no-container items collapse into a single (root).
    • Add / duplicate / delete on every node; a toolbar to add components (any of 35 types), groups/sections, and notebooks. Adding a Group / Section from a Notebook targets the currently selected Tab, falling back to the first Tab when no valid active Tab is available.
    • Drag-drop to reparent (onto a container) or reorder (onto a sibling).
    • Visual preview canvas rendering containers as boxes and components on a CSS grid by position.row/column; fixed component sizes map to extra-small=60px, small=120px, medium-minus=220px, medium=240px, medium-plus=260px, and large=320px, while percentage/full sizes remain fluid; in Real View, a Notebook with one Tab hides its redundant Tab header while multi-Tab Notebooks retain switching, field captions use 0.9em, RadioButton option captions use the live-form 16px → Preview 11px scale, and field cells in Side Label mode reserve the configured label column in addition to the field width, while Top Label mode keeps the original width; explicit numeric Text/InfoText font sizes use the live-form 16px → Preview 12px scale; captioned Section/Group titles show the concise resolved caption without the technical namespace icon while retaining the real Section type and structural name in the tooltip; Sections can be dragged into Cards, active Notebook Tabs, or root containers; add per box, delete per cell, and drag-drop in/out of containers.
    • Position warnings also appear in the Problems warning list. Each affected Card, Tab, or root container has a target-aware Fix positions action that recalculates only that container; the existing inline warning remains available.
    • Calculate positions compacts row groups and, within each row, distinct column groups to consecutive coordinates. Components sharing the same (row, column) remain stacked, and GridColumn / VerticalGridColumn table columns are excluded.
    • Properties panel for the selected component / section / notebook, including component_class { name, parameters }, enabled_when / visible_when / required_when, and component events.
  • Events tab — searchable, inline-editable table with add/delete. Responses grouped by event name; the array order within a group is the firing sequence. Move to event… opens a picker to send one response to another event (existing or brand-new) by name, which works regardless of the filter or scroll position, and the group header can duplicate the whole event — every response, in order, copied to a new <name>Copy event. Drag-drop still reorders within a group. When a filter hides part of a group the count badge reads 1/3, since reordering is relative to the hidden rows too. Every response row has an edit toggle: types with a structured editor (SetValues, GenerateEvent, MethodCall, ConditionalAction) open it when the value parses, and every other response opens a lossless multiline editor (Wrap toggle, Ctrl+Enter to apply, Esc to revert, original line endings preserved). The Conditional Action editor follows the official Conditional action syntax: one card per Type:targets, condition, value parameter, action-aware value controls, Expression / ELSE / empty-reuse conditions — edited in a condition builder (one row per comparison, joined by & AND / | OR) or as text with an insert menu for operators, functions and references — a plain-language meaning line, inline warnings (also reported in the Problems list as form-validation warnings), and add / duplicate / reorder / delete. Untouched parameters and trailing modifiers such as COLID(...) are written back exactly as they were. Multiline values show as a read-only row preview so their line breaks cannot be stripped by the one-line field.
  • Variables tab — searchable, inline-editable table with add/delete. Every row has an edit toggle that opens the same lossless multiline editor as the Events tab; multiline values (e.g. long SQL filter expressions) show as a read-only row preview so the one-line field cannot strip their line breaks.
  • Script tab — read-only view of the embedded form_script, editable in a real VB/C# editor. In that editor, Go to Event (F12 / Ctrl+Click) on a (ThisForm.)GenerateEvent("Foo") / PostEvent("Foo") call jumps to the event's FormScriptMethod handler in the same script (or the event's definition in the form JSON when it isn't a script method).
  • Focus Order tab — inspect each collection's derived field focus sequence beside its grid column order, with a one-click reorder fix when they diverge.
  • Grid column widths — apply one width standard to grid columns: Length × 8 + (listable ? 4 × 8 : 0), limited to 100–400 px; checkbox columns are a fixed 80 px. Length comes from the column's own LENGTH(n), its property_class, or the bound IDO property (via the optional jeking.mg-ido-pro-editor API); dates are 10 / 19 characters. When a grid has at most 10 visible columns and they fit the grid's width (checked only when that width can be worked out from the layout), the last visible text column becomes the single auto column (size 0) that fills the grid. Open the preview from the grid's property panel (Column widths…), the ruler icon on a canvas grid, or the Focus Order tab (per grid or All grids…); it shows current vs proposed sizes, has a per-form Auto-fit toggle (default from settings), and Apply writes only the sizes as one undoable edit. The canvas marks every size 0 column with a green underline and ↔. Commands IDS Grid Widths: Report / Apply (Current Form) (also in the designer's … menu), Report (All Forms)… (Markdown + JSON) and Apply Approved Report… (skips forms changed since the report). Every rule value is a slIds.gridColumnWidth.* setting.
  • IDO Usage side panel — inspect the structured IDO footprint computed by the Form Designer extension-owned API in a compact collapsible tree, including bound collections, datasource variables, event method targets, loaded collections, list lookups with their source components, and subcollection paths; filter by text or usage type, and click an IDO, component, or event to navigate directly to it. Shared side-panel tabs have equal-width cells for stable navigation.
  • Feature Gates side panel — every SyteLine feature the form depends on (both .ids and .iv2), detected from any Is…ActiveVar reference (declarative #GV(...) expressions, component enabled_when/visible_when/required_when/validators/list_source, event responses, and the embedded form_script). Features are grouped by feature ID with their usage places as a second level: click a usage row to jump to the variable, component, event, or script, or click the feature ID to open its Jira issue (base URL from slIds.jiraBrowseBaseUrl). Use Expand all / Collapse all to open or close every visible feature at once, or click the feature ID to open its Jira issue (base URL from slIds.jiraBrowseBaseUrl) — only feature ids under a known Jira project prefix (CSIB) are linked; internal SyteLine codes (RS…, etc.) render as plain text. A Delivery Tracking toolbar action opens the Feature Delivery Tracking wiki for checking release status. Activation status is resolved automatically and headlessly through the MG REST Client extension's public API (an AppFeatures LoadCollection), and each feature reports a Type-aware status — Force GA, GA Active, GA Off, Pre-Release On/Off, Hidden On/Off — with its FeatureType / ActivatedBy / ActivationDate beside the ID. Active is the authoritative on/off flag; ActivatedBy (INFOR/sa = force) applies to GA (A) rows only, since H/P features are never GA. Every verdict is an inference from editable AppFeature_mst rows, so the panel shows a prominent advisory: for reference only, verify against the database and the running configuration. The connection is reused from the MG REST Client's active profile, and the credential is borrowed from that extension's own Get Security Token command, so nothing has to be configured twice (override via slIds.mgRest.*, or store a secret with IDS Form: Set MG REST Password/Token). If it cannot authenticate, gates read Unknown with the reason, an inline button to store a credential, and Open activation SQL — a T-SQL script opened in a SQL editor that reads AppFeature_mst (the AppFeature view is site-scoped by CONTEXT_INFO(), so it returns nothing outside the middle tier), scoped to one site so the result is one row per feature. The COUI tab carries a compact entry point; feature gates are not part of the readiness score.
  • Component Flags editor — the Component Editor's flags field keeps its numeric fallback and opens a grouped checkbox popup for the readable ComponentFlags options. Shared enum aliases use one checkbox per bit, the aggregate value is recalculated live, tooltips include the enum names and bit values, and unknown flags are preserved.
  • Property Class navigation — the Component Editor property_class field exposes separate actions for the Form-level PropertyClassExtensions/<name>.sql file and the IDO Property Class XML. The Form-level action uses the effective forms folder; the IDO-level action uses the optional jeking.mg-ido-pro-editor extension and opens the selected class directly. The field remains fully usable without the IDO Editor extension.
  • Selected IDO Property navigation — the Property Editor's read-only IDO Property Details header opens the resolved target IDO in the Mongoose IDO Editor and focuses the exact property currently bound to the form component, including resolved subcollection properties.
  • Component Class / Property Class Ext. panels — under the IDO Property panel (JSON and XML designer), each class definition's settings as they apply to the component: %n filled from component_class.parameters, a value a nearer level overrides struck through (component › Component Class › Property Class Ext.), and every embedded V(name) resolved — form variable, template variable (e.g. SLDataMaintenanceTemplate.ids), global Variables/<name>.sql, nested values followed — or named as a Parm_ session parameter, set by this form (where), or set at run time. The Analysis tab's Settings by level shows the same resolution in its cell tooltips.
  • Unified right-side panels — the pinned Component Editor, IDO Usage, Event Graph, and Feature Gates share one compact surface and use Split (side-by-side) or Tabs layouts, set via slIds.sidePanelLayout (default tabbed); panel widths use shared geometry, Tabs mode uses one equal width, and narrow Split layouts fall back to Tabs regardless of the setting when the main designer no longer fits.
  • Menu preview — component menu_name references resolve against configurable SyteLine Menus/*.sql files, including known CSI/Mongoose product trees when slIds.menusFolder is unset.
  • Business flow tests (preview, flow/; design docs/design-business-flow-tests.md) — one business flow document (*.flow.md) drives UI tests in WSWebClient (classic, IDS, iv2) and API tests (Mongoose REST V2 / V3) through a business object catalog and mappings to forms / components and IDOs / properties. The standalone engine node dist/flow-engine.js validate | run | import | report needs only Node (and playwright-core for UI targets, not bundled: Flow: Install Playwright… installs it with npm install -g playwright-core after you agree and names it in the configuration as browser.playwrightCore; a run with a UI target and no playwright-core stops before it starts and offers it). Flow: Build Standard Preset… writes a catalog and mappings from the IDOs and forms of a checkout; COUI Code Out writes spec/flow-import.json drafts. Files live in the folder slIds.flow.configFile names (default ~/SLFlow/flow.config.yaml). In VS Code, the CodeLenses above each scenario of a *.flow.md run it on a target (with its latest result shown), the Flow Results view shows runs, scenarios, steps and evidence, and Problems shows what validate finds on save; Flow: Store Secret… keeps a profile's token or password in VS Code's secret storage. Flow documents are highlighted, and offer completion (catalog objects and fields in […], symbols in {…}, variables, keywords, steps) and hover (a field's IDO property and form components). Flow: Open Demo… copies a demo flow root shipped with the extension to a folder of yours to start from: samples/flow-demo (Co-product Mixes) or samples/flow-p2p (a new item bought from a new vendor and received on Purchase Order Receiving; it leaves its records, since a receipt cannot be deleted); their environment profiles hold placeholders for your server, configuration, site and users. Utility forms (posting and generating forms such as Purchase Order Receiving) are catalog objects of kind: utility (their parameters, the rows they load as kind: rows, their buttons) with a form mapping written by hand, each row column found by the property it is bound to: Given open [X] with … types the parameters, set clicks a checkbox field or cell when its state differs, run [X.Action] clicks the button; until their API way is mapped they run on forms only (a step on one is not applicable to the API). A NumSortedString key (VendNum, PoNum: numSorted: true in the catalog, written by the preset) goes through the API expanded as the system expands it (DP189 → DP00000189). In the flow configuration, browser: { headless: false, slowMo: 300, screenshots: steps } shows and slows the browser and shoots every step, and summary: html writes an HTML summary with the screenshots. Print <value>, …, Print messages and Print screenshot write what a run sees (a variable, a record with its fields, a field as the form or the record holds it, the open messages) into the results and, as the run goes, the "SL Flow" output; the debug CodeLens (Flow: Debug Scenario…) runs a scenario or process with every step written there as it starts and ends, the browser shown, every step shot and no retries. Flow documents can sit in folders under the flows folder (a flow's id is its path, e.g. Sales/Orders; a run can name a folder, Sales/). A process document (*.process.md) runs steps in order on one session: scenarios of the flows (Step Sales/Orders SO-1 with <Customer> = {AnyCustomer} outputs <Order>) or steps written in place (Step Make an item on API), passing values and records from step to step; the records are deleted at the end, newest first, unless it Leaves records. Flow: Open Manager (Preview) shows the flow root on one page: flows by folder with their review state and latest results (summary cards, search and status filters; run a folder or a flow, create a folder or a flow), the coverage of each object by the API and form mappings (read when you ask, kept until the mappings change), a to-do list grouped by flow and the settings; Flow: Switch Flow Root. moves between flow roots (also from the status bar). Its Settings tab (Flow: Settings) edits the configuration and the environment profiles in place (only the changed keys; each file checked by the flow reader before it is written) and tests a profile's API and UI connections. The Flow Statements view (IDS Forms sidebar; its title bar also has Open Manager, Settings and Install Playwright) and Flow: Statement Reference list every statement of the flow language with examples; Insert puts one at the cursor, and Shift+F1 in a flow document opens the reference at the statement of the line. Flow documents open as the SL Flow language (Ctrl+Shift+V for the Markdown preview), with an outline, Go to Definition (F12: the catalog line of a reference, the definition of a {Symbol}, <Variable> or procedure), Go to Implementations (Ctrl+F12: a field's IDO property and form components) and Find All References. For the checks, completion and the Manager the editor keeps one engine process running (flow-engine serve) that reads only the files changed since its last answer. The Business Objects view, the mapping editor and Dev Hub entry points are later phases; the MCP server's flow_* tools (below) let an agent check, write and run flows.

Every edit mutates the parsed JSON and re-serializes with the exact SyteLine convention — JSON.stringify(obj, null, 2) with CRLF, no BOM, no trailing newline — so diffs stay clean. Verified byte-for-byte against real forms up to 2.1 MB / 1,724 components.

Business flow tests from a command line

npm run test:editor (after npm run build) checks the flow editor in the installed VS Code: a separate instance with its own settings opens a copy of the demo root and checks highlighting, completion, hover, CodeLenses, the outline, Go to Definition, references, the problems on save, Enter's indentation, Help and the webviews on a flow and a process document; -- --live <environment.yaml> also runs the demo process from its CodeLens on that environment.

When the editor uses a flow root, it copies its flow engine there: <root>/engine/flow-engine.js (one file, no dependency, Node.js 18 or later), engine.json (its version and SHA-256) and a README.md. An older engine is replaced and a newer one kept; Flow: Copy Engine to the Flow Root copies it on demand, slIds.flow.engineCopy: false turns the copy off. In the flow root:

node engine/flow-engine.js --version                                   # flow-engine 3.327.0
node engine/flow-engine.js validate --config flow.config.yaml          # exit 1 on an error
node engine/flow-engine.js run --config flow.config.yaml --run run.json [--json] [--secrets-stdin]
node engine/flow-engine.js report --results <run folder>
node engine/flow-engine.js probe --config flow.config.yaml [--profile <name>]

A run request names the flows ("flows": ["Sales/"], ids, folders or *), the targets (api, ui:ids, ui:iv2, ui:classic; the API's dialect, V2 by default or V3, is the environment profile's api.dialect), the languages, and which IDOs or forms ("api": { "idoTypes": ["ids"] }, "ui": { "formTypes": ["ids"] }). No secret is an argument or in a file: a profile's secret: is none, env:<NAME>, dpapi:<file> or stdin ({"<profile>": {"password": "…"}} on standard input with --secrets-stdin). The results (results.json, the summary, screenshots, requests and responses) go to the configuration's results folder; the exit code is 1 when a scenario failed, errored or was blocked.

Performance

The webview skips a full rebuild when a state push changes nothing visible (a structural render signature gates re-renders), builds the container tree once per render, and preserves scroll positions. On a 1,724-component form: tree build ≈ 0.6 ms, signature check ≈ 0.6 ms.

Architecture

Area Files
JSON round-trip src/model/idsJson.ts
Model + container tree src/model/idsFormModel.ts
Enums (mined from 2,466 forms) src/model/enums.ts
Edit operations + factory src/model/editOps.ts, src/model/itemFactory.ts
Validation src/model/validate.ts
Custom editor host src/editor/formEditorProvider.ts
Webview shell + state src/webview/main.ts, appContext.ts, panels.ts, panelShell.ts, signature.ts
Views src/webview/views/{formTab,layoutTab,tree,preview,props,eventsTab,variablesTab,scriptTab,issuesPanel,featureGatesPanel}.ts
Schema tooling scripts/mine-schema.js → docs/ids-form-structure.md

MCP server (sl-ids-forms)

The extension ships a dependency-free MCP server so an MCP-capable agent (e.g. Kiro) can read and edit IDS/IV2 forms with the same engine the visual designer uses. It reuses the pure model modules, so edit semantics never diverge between the UI and the agent.

Enable it

  1. Run the command “IDS Form: Register MCP Server with Kiro” (choose User or Workspace scope). This writes an entry into .kiro/settings/mcp.json and, on Windows, a resilient mcp-sl-ids.cmd launcher next to it.
  2. Set slIds.idsRoots to the folder(s) that contain your *.ids.json / *.iv2.json forms (passed to the server as MG_IDS_ROOTS). Re-run the register command after changing it.
  3. Reload Kiro to pick up the server. Use “IDS Form: Unregister MCP Server from Kiro” to remove it.

On upgrade the extension self-heals an existing sl-ids-forms registration: activation rewrites the stale, version-pinned launcher path and reconciles its autoApprove list (adding tools introduced in the new version — a union that never removes your extras), so you don't have to re-run Register just to pick up a new tool. Only registrations written by this extension are touched; custom paths are left alone.

Settings

Setting Purpose
slIds.idsRoots Folders searched for forms (MG_IDS_ROOTS).
slIds.menusFolder Optional Menus directory or specific Menus/*.sql file; when unset or invalid, the effective forms folder's Menus directory is indexed first, then workspace-derived CSI/Mongoose product trees are used as per-menu fallbacks.
slIds.mcpNodePath Optional explicit Node executable (instead of the Windows .cmd / Electron-as-Node launcher).
slIds.mgRest.server / .config / .username Optional overrides for the Feature Gates activation lookup; empty reuses the MG REST Client's active profile.
slIds.mgRest.secretIsToken Treat the stored MG REST secret as a security token instead of a password.

Method-usage commands — slIds.findFormsUsingMethod opens an interactive Markdown report; integrations can call slIds.findFormsUsingMethodData(ido, method, caseSensitive?) to receive the MethodUsageReport directly without prompts or UI. Both commands use configured slIds.idsRoots, falling back to the resolved slIds.formsFolder when no roots are set.

Corpus-validation command — slIds.scanForms opens the interactive Problems-panel scan; integrations can call the Property-usage API — integrations can call slIds.findComponentsBoundToPropertyData(ido, property, options?) to receive a ComponentBindingUsageReport containing every direct IDS/IV2 component binding, absolute form path, variant, component/container metadata, and a serializable layoutNode target. Pass includeSubcollections: true to resolve metadata-backed subcollection bindings. Use the returned target with slIds.selectLayoutNode to open or activate the form and select the control in the designer.

headless slIds.validateAllFormsData(root?) to receive { scanned, forms:[{ form, path, errors, warnings, issues:[{ severity, where, message }], readiness? }], readiness:[{ form, path, pct }] } directly, with no prompts or UI. forms lists issue-forms worst-first; each .iv2 row and the top-level readiness[] (every scanned .iv2 form) carry the COUI readiness % — scored baseline-relative to the .ids sibling, matching the Forms Explorer badge (pct 0–100 or null). It uses configured slIds.idsRoots (falling back to the resolved slIds.formsFolder), or an explicit root. Shares the validateForm and couiReadiness engines with the designer, so results never diverge.

Tools (76) — read-only form inspectors (form_list, form_get_model, form_validate, form_get_component, form_get_variable, form_get_section, form_get_notebook, form_get_tree, form_list_events, form_list_missing_variables) plus form_report_issues (batch-scan the whole corpus and report every form's validation issues — the corpus-wide form of form_validate, with error/warning/suggestion counts and totals; json/markdown/html), form_find_method_usages (scan the configured corpus for one IDO method, reporting declarative event calls separately from raw form_script Invoke/InvokeIDOMethod calls) and form_find_orphan_events (orphan Form events across the corpus, see Orphan Events below), a dedicated, self-describing tool for every one of the designer’s 32 edit operations (add/rename/delete/move/reparent components, sections, notebooks, cards, tabs, variables, events, form fields), and form_apply_edit as a raw escape hatch.

  • Property bindings and form scripts — form_find_property_bindings (every component bound to one IDO property, as the Find Components Bound to an IDO Property command), form_script_get (numbered lines, a range or a search) and form_script_set (whole text, or a find/replace block that must match once; dry run by default), form_idos_used_batch (the IDOs of many forms, and the forms of each IDO).
  • Business flow tests — flow_statements (the flow language reference), flow_validate, flow_overview, flow_describe (named objects only), flow_coverage, flow_results, flow_run_status (read-only), and flow_new, flow_set_scenario (one scenario block, checked with the whole root before it is written), flow_probe, flow_run (returns a runId at once; poll flow_run_status). They use the flow root VS Code has selected (flow-current.json in the extension's storage, refreshed on every switch) or a config argument. No tool takes a secret: profiles with secret: none, env: or dpapi: run; secret: stdin (VS Code's secret storage) is reported blocked. Design: docs/design-mcp-flow-and-form-tools.md.

Also included:

  • Compare with Classic — form_compare_classic (diff one IDS form against its matching classic form) and form_report_mismatches (batch-scan all forms for component mismatches; json/markdown/html).
  • IDS ↔ IV2 (COUI) — form_compare_ids (structurally diff a form against its .ids/.iv2 sibling), form_coui_readiness (client-logic migration score, plus a layout-parity section when the sibling exists; for an .iv2 form it also scores the _IDS IDO rule — every referenced IDO should be the _IDS variant, with MGCore framework IDOs exempt — and lists the offenders by name; also exposes structured signals — logicMigrated, per-type formConfig, ground-truth remaining counts, and optional per-category weights — for an external gating layer), and form_report_parity (batch-scan all .ids/.iv2 pairs for layout gaps — missing/extra/moved/component_specific; json/markdown/html). The designer surfaces the same parity in the COUI tab (with per-item / bulk Adopt from .ids apply-with-preview), and via the “Report IDS↔IV2 Layout Parity” command. The Forms side panel also badges each .iv2 leaf with its COUI score and, when present, the validation error/warning counts (e.g. COUI 40% · ✖1 ⚠3; full breakdown in the tooltip), and can be filtered by that status (“Filter Forms by Status…” — has errors / has warnings / clean / COUI thresholds, AND-combined with the name filter).
  • Global scripts (Scripts/*.sql) — global_script_list, global_script_get (decode to VB/C# code), global_script_set (edit code, re-encoded with the original file format preserved; dry-run/apply), and global_script_search. Point MG_SCRIPTS_ROOTS at the Scripts folder (else the IDS roots are used). Global-script method resolution is intentionally outside the v1 form_find_method_usages scan, so calls reached indirectly through RunScript remain a known blind spot.
  • Orphan Events — a Form event that no entry point in its own form reaches (standard events, component events, validators, menus, prompt buttons, …Event= callback variables, live form script). The Event Graph tags each one Orphan · certain|likely|possible (and Code Out when the .ids.json sibling of an .iv2.json still fires it), tags events reached only because their name appears in live code By name only, and filters to both with Only orphan events; JSON and XML forms alike. IDS Form: Find Orphan Events and form_find_orphan_events scan the corpus (.ids.json, .iv2.json, hand-written XML form folders; *.autogen is skipped) and add global-script and other-form signals. An orphan is a suggestion: another form, a global script, a template or the framework may still fire it, so removing it is your decision. Design: docs/design-orphan-events.md.

Safety model

  • All mutating tools are dry-run by default and require apply:true to write; they re-validate after every change and preserve the exact byte conventions (CRLF/BOM/indent).
  • Only the read-only tools are in the registration’s autoApprove list; every write requires approval.
  • Path scope: the server reads/writes any absolute path it is given (there is no workspace sandbox). This is intentional for a local developer agent — point slIds.idsRoots at trusted form folders and be aware that apply:true calls modify files on disk.

Develop

npm install
npm run build            # bundle extension + webview
npm test                 # 79 unit + integration tests
npm run watch            # rebuild on change
npm run mine-schema <dir>            # profile a folder of *.ids.json
npm run mine-schema <dir> -- --doc docs/ids-form-structure.md
npm run gen:mg-enums                 # Windows (pwsh.exe): regenerate src/xmlform/mgEnums.generated.ts from an installed WSEnums.dll
npm run gen:mg-ids-components        # Windows: regenerate src/xmlform/idsComponents.generated.ts from the installed web client's
                                     #   ComponentStore.js (the Mongoose designer's "Component Specific" settings); optional
                                     #   --strings <json> adds the designer's English help texts (LIT$ dumped from a logged-in designer page)

Press F5 to launch an Extension Development Host, then open any *.ids.json.

Not yet implemented

Template (form.template) resolution to show template-provided panes by real name; expression autocomplete for the when rules; multi-select drag.

  • Contact us
  • Jobs
  • Privacy
  • Manage cookies
  • Terms of use
  • Trademarks
  • Your Privacy Choices
  • Consumer Health Privacy
© 2026 Microsoft