ConnXL Docs

Build

Excel resources reference

Beyond functions, an environment can carry ten kinds of Excel artifact — charts, tables, dialogs, formatting, and more — that the agent applies live from config. This page covers all ten, in depth for the three novel ones (charts, grid views, dialogs) and to the point for the rest.

10 min read

Every environment's Resources tab holds more than functions. Ten resource kinds — Charts, Tables & Pivots, Dialogs, Conditional formatting, Named ranges, Comments, Protections, Data validations, Image inserts, and Worksheet events — let you shape how Excel looks and behaves without writing a single line of Office.js.

Config-only, applied live — no manifest, no re-deploy

All ten are passthrough resources: the dashboard stores config, that config rides the same snapshot channel as your functions, and the connxl-agent applies it directly (draws the chart, writes the comment, registers the event handler, and so on) rather than executing it like a function. None of them touch the Office manifest, so a change is live the next time a user opens the taskpane — no re-deploy, no re-sideload. Save a live version of the environment to publish, exactly like a function change.

Charts

An Excel chart drawn over the spilled output of a matrix-shaped function (Table, Row, or JSON output — see Functions reference). Reach for a chart when you want the same visualization a user would build by hand from a spill, refreshed on every insert.

Configure it from the Resources tab → Charts: pick the source function, a chart type (ColumnClustered, ColumnStacked, BarClustered, BarStacked, Line, LineMarkers, Pie, Doughnut, Area, or XYScatter), and optionally a title, a legend toggle, and category/value axis titles.

FieldTypeDescription
seriesOptional
repeatableLeave empty to let the agent derive series automatically from the spilled range. Or add explicit series, each naming a valuesFrom column (and an optional fixed color) — for a table-mode source with declared columns, the builder offers a picker over the real headers instead of free text.

Shape-aware series

If the source function declares its output columns, the series picker shows the real headers (numeric columns first) and the preview draws the actual resolved series — a series naming a column that no longer exists is struck through in the preview and would be silently dropped by the agent, so you catch drift before publishing.

In Excel: opening the resource from the built-in taskpane panel spills the source function, then draws the chart over the result as a real Excel chart object (not a picture) — it can be moved, resized, and restyled by the user afterward like any other chart.

Grid views (Tables & PivotTables)

Turns a matrix function's spilled output into a real Excel Table or PivotTable, instead of a bare dynamic-array spill. It's the "Tables & Pivots" tab of Resources.

Configure it: pick the source function (matrix-shaped only), then an ordered list of Arguments — the positional values passed to the function when it's spilled (e.g. "West", 10) — followed by kind-specific options:

FieldTypeDescription
kindRequired
table | pivotWhich Excel object the spill is wrapped into.
table.style / table.hasHeadersOptional
string / boolTable kind only — the Excel table style name and whether the first spilled row is a header row.
pivot.rows / pivot.columnsOptional
string[]Pivot kind only — field names driving the row and column hierarchies.
pivot.valuesOptional
{ field, aggregation }[]Pivot kind only — one or more value fields, each with an aggregation: sum, count, average, max, min, product, countNumbers, stdDev, or variance.
pivot.refreshOnOpenOptional
boolPivot kind only — re-pull the source data every time the workbook opens.

When the source function declares its output columns, the row/column/value pickers render as chip selectors over the real headers (a stale saved field shows as a removable danger chip) instead of free text.

A Table from a spill is a static snapshot

Wrapping a spill in a Table replaces the underlying dynamic-array formula with its values — a hard Office.js constraint, not a ConnXL limitation. It won't live-update if the source data changes on its own; re-insert it (or wire a worksheet event, further down this page, to reapply it) to refresh.

In Excel: clicking the grid view in the taskpane spills the source function with its configured arguments, then wraps the result — a Table via worksheet.tables.add, or a PivotTable via workbook.pivotTables.add with the configured row/column/value layout.

Dialogs

A form-based launcher for a function that takes several parameters. Instead of asking a user to type =NAMESPACE.MODULE.FN(v1, v2, v3) by hand, a dialog opens a labelled form and composes the call for them.

Configure it: pick a source function — only functions with parameters are offered. Choosing one auto-seeds the dialog's field list from that function's parameters, in order (key, label, optional placeholder); each field's key is restricted to one of the function's own parameter names, and only trailing optional parameters may be dropped from the field list — anything else is rejected, both in the builder and by the API, so a dialog can never drift out of sync with its function's signature.

A dialog opens a separate window, not an inline form

The dialog is not part of the taskpane's own DOM. Opening it (from the taskpane's built-in Dialogs card, or a ribbon button wired to it) launches a genuinely separate Office Dialog window via Office.context.ui.displayDialogAsync. It renders one labelled <input> per configured field. On submit, the window sends the collected values back to the taskpane (messageParent), which composes and inserts the formula — arguments in the same order as the field list:

composed formulaexcel
=NAMESPACE.MODULE.FN(v1, v2, v3)

No manifest entry is needed for a dialog — the window is served from the same origin as the agent host, which already satisfies the Office Dialog API's same-origin rule, so there's nothing to add to <AppDomains> and no re-deploy.

Conditional formatting

Dashboard-configured cell-value rules applied over a matrix function's spilled range — highlight thresholds, outliers, or categories without a user setting up Excel's Conditional Formatting dialog by hand.

Configure it: pick the source function, then add one or more rules, each an operator (greaterThan, lessThan, between, equalTo, notEqualTo, greaterThanOrEqual, lessThanOrEqual) against one formula bound (two for between), with an optional fill color and/or font color. Rules apply in order — the first match wins. The builder's preview is a rule debugger: it derives sample values from your rules' own numeric bounds and tints each sample cell by the first rule it matches (a formula bound stays un-evaluated, marked with an ƒ badge).

In Excel: applied to the same range the source function spills into, using Excel's real cell-value conditional-format rules — it re-evaluates as the underlying values change, it isn't a one-time paint.

Named ranges

Binds an Excel defined name to a matrix function's spilled output, so the range can be referenced by name — in other formulas, or via the Name Box — instead of by cell coordinates.

Configure it: pick the source function, a scope (workbook or worksheet), and an optional comment on the defined name.

In Excel: the source function is spilled, then the resulting range is named as a real Excel defined name (workbook.names.add or worksheet.names.add) — usable immediately in any other formula in the workbook.

Comments

A static cell comment (note), anchored to a specific cell — unlike the resources above, a comment is not sourced from a function; it's just text on a cell.

Configure it: a target address (optionally sheet-qualified, e.g. Sheet1!B2) and the comment text.

In Excel: written onto the target cell through Office's comments API when the agent applies the resource.

Protections

Locks a worksheet down while leaving a chosen set of actions available — useful for a published reporting sheet you don't want end-users editing, while still letting them sort or filter it.

Configure it: a target sheet (blank applies to whichever sheet is active when the resource is applied), and nine allow-* toggles: format cells, format columns, format rows, insert columns, insert rows, delete columns, delete rows, sort, and AutoFilter.

Every permission rides explicitly

All nine flags are always sent to the agent, not just the ones you turned on — so an unchecked permission is actively locked rather than left at whatever Excel would default it to.

In Excel: applied as a worksheet protection (Excel's WorksheetProtectionOptions) with your chosen permissions left open.

Data validations

A real, editable Excel data-validation rule on a target range — not a one-time check, an ongoing constraint on what a user can type into those cells.

Configure it: a target address (a single cell or a range, optionally sheet-qualified), and a kind:

FieldTypeDescription
listOptional
kindA dropdown of explicit values, with a toggle for the in-cell dropdown arrow.
wholeNumber / decimal / date / textLengthOptional
kindA comparison rule: pick an operator (between, notBetween, equalTo, notEqualTo, greaterThan, lessThan, greaterThanOrEqualTo, lessThanOrEqualTo) and one or two formula bounds (two only for the between-family operators).
customOptional
kindAn arbitrary validation formula.

In Excel: applied via range.dataValidation.rule — the user sees the same in-cell validation (and dropdown arrow, for a list) as if they'd set it up themselves in Excel's Data Validation dialog.

Image inserts

Drops an uploaded org image — from the same Assets → Images library used elsewhere in the dashboard, shared across the whole org's add-ins and environments — into the worksheet grid, anchored to a cell.

Configure it: pick an org image, an anchor cell address (its top-left corner lands there), and a scale factor relative to the image's natural size.

In Excel: the agent fetches the image through the backend's image proxy at apply time and inserts it at the anchor cell. If the referenced image is later deleted from the Assets library, the insert is skipped gracefully rather than failing the whole snapshot.

Worksheet events

Registers a worksheet-event handler that fires a configured action automatically — no user click required. This is what makes the other passthrough resources feel "live."

Configure it: a trigger (onChanged or onSelectionChanged), then an action:

  • Reapply resource — names a target kind (chart or gridView) and id; when the trigger fires, the agent re-applies that resource — redrawing the chart, or re-spilling and re-wrapping the grid view, over its latest source data.
  • Execute function — names a function id; when the trigger fires, the agent runs that function for its side effects (e.g. writing somewhere), not for a value returned into a cell.

In Excel: the agent registers the handler with Office.js's worksheet.onChanged or worksheet.onSelectionChanged when the taskpane opens. Pair this with a grid view (above) that has no live refresh path of its own — an onChanged event is the usual way to keep a Table-from-spill in sync with upstream changes.

Promoting resources across environments

Every resource kind above follows the same structural rule as functions: it can only be created or edited in the source environment (Development). Every other environment is a promote target — you bring a chart, grid view, dialog, or any of the others into a downstream environment with Promote, the same action you'd use for a function or connection, from the environment's Versions page.

Nothing here is manifest-gated

Because none of these ten resources touch the Excel manifest, promoting or editing any of them is always a config-only change — the receiving environment's agent picks it up over its existing config stream, with no re-deploy and no re-sideload, exactly like a function.

On this page