@ukhomeoffice/formio-gds-template 3.0.0-alpha → 3.0.0-bravo

package/lib/components/select/GDSSelect.js

@@ -0,0 +1,340 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const js_1 = require("@formio/js");
+const lodash_1 = __importDefault(require("lodash"));
+const Select = js_1.Components.components.select;
+class GDSSelect extends Select {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+    constructor(component, options, data) {
+        super(component, options, data);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    init() {
+        var _a, _b;
+        // Clear searchField so Form.io does not trigger server-side queries while
+        // the complete reference dataset is filtered locally.
+        if (this.component.searchField) {
+            this.component.searchField = '';
+        }
+        // Reference-data selects are filtered locally. Do not truncate the
+        // alphabetically sorted API response before local filtering.
+        const url = (_a = this.component.data) === null || _a === void 0 ? void 0 : _a.url;
+        if (typeof url === 'string' && url.includes('/v2/entities/') && ((_b = this.component.limit) !== null && _b !== void 0 ? _b : 100) < 1000) {
+            this.component.disableLimit = true;
+        }
+        return super.init();
+    }
+    /**
+     * Patch the choices.js instance attached to this component so that every
+     * search query uses a plain case-insensitive substring filter instead of
+     * fuse.js. The patch is applied lazily the first time items are set so
+     * that `this.choices` is guaranteed to exist.
+     */
+    _patchChoicesSearch() {
+        const choices = this.choices;
+        if (!choices || choices === this._gdsSearchPatchedChoices) {
+            return;
+        }
+        this._gdsSearchPatchedChoices = choices;
+        // Replace the internal search method with a substring implementation.
+        choices._searchChoices = (needle) => {
+            var _a;
+            if (!needle) {
+                choices._isSearching = false;
+                choices._currentValue = '';
+                choices._store.dispatch({ type: 'ACTIVATE_CHOICES', active: true });
+                return 0;
+            }
+            const normalizedNeedle = needle.trim().toLowerCase().replace(/\s{2,}/g, ' ');
+            if (!normalizedNeedle || normalizedNeedle === choices._currentValue) {
+                return null;
+            }
+            const words = normalizedNeedle.split(/\s+/).filter(Boolean);
+            const allChoices = choices._store.choices;
+            const matched = [];
+            const prefix = [];
+            const contains = [];
+            for (const choice of allChoices) {
+                const renderedLabel = ((_a = choice.choiceEl) === null || _a === void 0 ? void 0 : _a.textContent) || '';
+                const label = [choice.label, renderedLabel, choice.value]
+                    .map((value) => String(value !== null && value !== void 0 ? value : '').toLowerCase())
+                    .join(' ');
+                const allMatch = words.every((w) => label.includes(w));
+                if (!allMatch) {
+                    choice.active = false;
+                    choice.rank = 0;
+                    continue;
+                }
+                if (label.startsWith(normalizedNeedle)) {
+                    prefix.push(choice);
+                }
+                else {
+                    contains.push(choice);
+                }
+            }
+            // Prefix matches first, then other substring matches, both sorted
+            // alphabetically within their group.
+            prefix.sort((a, b) => a.label.localeCompare(b.label));
+            contains.sort((a, b) => a.label.localeCompare(b.label));
+            [...prefix, ...contains].forEach((choice, index) => {
+                matched.push({
+                    item: choice,
+                    score: 0,
+                    rank: index + 1,
+                });
+            });
+            choices._isSearching = true;
+            choices._currentValue = normalizedNeedle;
+            choices._store.dispatch({ type: 'FILTER_CHOICES', results: matched });
+            return matched.length;
+        };
+    }
+    /**
+     * True when this select's `filter` is interpolated from other form data
+     * (e.g. a port list filtered by the selected country).
+     */
+    get _gdsHasDynamicFilter() {
+        return typeof this.component.filter === 'string' && this.component.filter.includes('{{');
+    }
+    /** The interpolated filter, used to detect when the dependency changed. */
+    _gdsCurrentFilterKey() {
+        return this._gdsHasDynamicFilter ? this.interpolate(this.component.filter) : '';
+    }
+    // Preserve Form.io's item lifecycle, then patch the Choices instance that
+    // Form.io has populated.
+    setItems(items, fromSearch) {
+        super.setItems(items, fromSearch);
+        if (!fromSearch) {
+            this._gdsFilterKey = this._gdsCurrentFilterKey();
+        }
+        this._patchChoicesSearch();
+    }
+    // Also patch on attach in case setItems was already called.
+    attach(element) {
+        const result = super.attach(element);
+        this._patchChoicesSearch();
+        return Promise.resolve(result);
+    }
+    // Form.io only refreshes a URL select with an interpolated filter when the
+    // component is redrawn, or when it transitions hidden -> visible (see the
+    // `visible` setter in Select). A select that is already visible when its
+    // filter dependency changes is therefore never re-fetched, leaving stale
+    // options (e.g. changing country a second time keeps the first country's
+    // ports). checkComponentConditions runs for every component on every data
+    // change, so compare the interpolated filter here and reload when it moves.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
+    checkComponentConditions(data, flags, row) {
+        var _a;
+        const visible = super.checkComponentConditions(data, flags, row);
+        // `_gdsFilterKey` is only set once options have been loaded, so this
+        // cannot force a premature fetch for a lazyLoad select that the user has
+        // not opened yet. Note `active` is deliberately not checked: Form.io's
+        // `visible` setter calls triggerUpdate() without calling activate(), so
+        // a loaded lazyLoad select can still report active === false.
+        if (visible &&
+            this.component.dataSrc === 'url' &&
+            this._gdsHasDynamicFilter &&
+            this._gdsFilterKey !== undefined &&
+            !this.loading) {
+            const filterKey = this._gdsCurrentFilterKey();
+            if (filterKey !== this._gdsFilterKey) {
+                // Record before requesting so a change that arrives while the
+                // request is in flight does not queue a duplicate fetch.
+                this._gdsFilterKey = filterKey;
+                (_a = this.triggerUpdate) === null || _a === void 0 ? void 0 : _a.call(this, null, true);
+            }
+        }
+        return visible;
+    }
+    // formio's redraw() and activate() both call triggerUpdate() -> updateItems(null, false),
+    // which would cause a URL re-fetch even when items are already cached. We suppress
+    // the re-fetch when the cache is valid, but we must still re-populate choices.js
+    // with the cached items. This matters because activate() calls setLoadingItem()
+    // before triggerUpdate(), which replaces the choices list with a spinner. Without
+    // re-calling setItems the spinner stays even though data is already available.
+    //
+    // Filter-dependency changes (refreshOn) always arrive with forceUpdate=true via
+    // Select.refresh(), so they bypass this guard and fetch fresh data as expected.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    updateItems(searchInput, forceUpdate) {
+        if (!forceUpdate &&
+            !searchInput &&
+            this.component.dataSrc === 'url' &&
+            this._gdsFilterKey === this._gdsCurrentFilterKey() &&
+            Array.isArray(this.downloadedResources) &&
+            this.downloadedResources.length > 0 &&
+            !this.loading) {
+            // Re-populate choices from the cache so any spinner set by activate()
+            // is replaced with the actual items, then resolve the loaded promise.
+            this.setItems(this.downloadedResources, false);
+            return;
+        }
+        return super.updateItems(searchInput, forceUpdate);
+    }
+    /**
+     * Override getOptionTemplate to escape item data values with `_.escape()`
+     * before interpolating them into the template.
+     *
+     * ## Security model
+     *
+     * formio 5.x `getOptionTemplate` (ListComponent) passes the assembled template
+     * string through `DOMPurify.sanitize()` — which internally calls
+     * `DOMParser.parseFromString()`. With thousands of reference-data items this
+     * is the dominant performance cost (~300 ms).
+     *
+     * We replace that post-hoc sanitization with pre-interpolation escaping:
+     *
+     * 1. Every string value in the item object is passed through `_.escape()`
+     *    **before** it is substituted into the template. `_.escape` converts
+     *    `< > & " '` to their HTML-entity equivalents (`&lt;` etc.).
+     * 2. The assembled template string — now containing only safe entity-encoded
+     *    text where user/API data appears — is returned directly without any
+     *    further DOMPurify call.
+     *
+     * ### Why this is equivalent security to DOMPurify for text-content templates
+     *
+     * A template such as `<span>{{ item.name }}</span>` embeds the API value as
+     * the *text content* of an element. The only injection vector is:
+     *
+     * ```
+     * item.name = '</span><script>alert(1)</script>'
+     * ```
+     *
+     * After `_.escape()` this becomes:
+     *
+     * ```
+     * &lt;/span&gt;&lt;script&gt;alert(1)&lt;/script&gt;
+     * ```
+     *
+     * The browser renders this as literal text, never as markup or script.
+     * DOMPurify would produce the same effective result by stripping the tags.
+     *
+     * ### Limitation — attribute / URL contexts
+     *
+     * `_.escape()` is **not** sufficient if the template places a value inside
+     * an HTML attribute or a URL (e.g. `<a href="{{ item.url }}">`).
+     * HTML-entity encoding does not prevent `javascript:` injection in `href`.
+     * If any form schema introduces such a template, this override must be
+     * revisited and either DOMPurify reinstated or the attribute value
+     * sanitized separately.
+     *
+     * Current GDS templates are all text-content only (`<span>{{ item.name }}</span>`
+     * etc.) so this limitation does not apply today.
+     */
+    getOptionTemplate(data, value, index) {
+        var _a, _b;
+        if (!this.component.template) {
+            return String((_a = data.label) !== null && _a !== void 0 ? _a : '');
+        }
+        const options = { noeval: true, data: {} };
+        // Escape all top-level string values in the item before interpolation.
+        // Nested objects are left as-is; they would need to be accessed via
+        // item.nested.field in the template, which is not used by current schemas.
+        const escapedData = lodash_1.default.mapValues(data, (v) => (typeof v === 'string' ? lodash_1.default.escape(v) : v));
+        const template = this.component.template
+            ? this.interpolate(this.component.template, { item: escapedData }, options)
+            : String((_b = data.label) !== null && _b !== void 0 ? _b : '');
+        // Store template data for reference-field selected-value display.
+        // The `reference` flag is not in the generated CoreSelectComponent type
+        // but is a valid runtime formio property.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const isReference = Boolean(this.component.reference);
+        const rawId = value === null || value === void 0 ? void 0 : value._id;
+        const templateValue = isReference && rawId != null
+            ? String(rawId)
+            : value;
+        if (templateValue != null &&
+            !lodash_1.default.isObject(templateValue) &&
+            options.data.item) {
+            this.templateData[templateValue] = options.data.item;
+        }
+        if (lodash_1.default.isNumber(index)) {
+            this.templateData[index] = options.data.item;
+        }
+        return template;
+    }
+    /**
+     * Override itemTemplate to skip the redundant outer `sanitize()` call that
+     * formio 5.x `ListComponent.itemTemplate` wraps around `getOptionTemplate()`.
+     *
+     * ## Why the outer sanitize is now safe to skip
+     *
+     * Our `getOptionTemplate` override (above) pre-escapes all API data values
+     * with `_.escape()` before they are interpolated into the template. The
+     * assembled string therefore contains no unescaped HTML from variable sources.
+     * Running DOMPurify on that string a second time is idempotent — it produces
+     * the same output — but costs a full `DOMParser.parseFromString` call per item.
+     *
+     * This override handles only the common URL-datasource path (object data with
+     * a component template). All other branches — primitives, arrays, read-only,
+     * selectData, reference fields — fall through to `super.itemTemplate` which
+     * retains its full sanitize() call unchanged.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    itemTemplate(data, value, index) {
+        if (typeof data === 'object' &&
+            data !== null &&
+            !Array.isArray(data) &&
+            this.component.template) {
+            // getOptionTemplate pre-escapes data values — no further sanitize needed.
+            const template = this.getOptionTemplate(data, value, index);
+            if (!template) {
+                return this.sanitize(JSON.stringify(data), this.shouldSanitizeValue);
+            }
+            // Strip tags to extract the visible label text for i18n translation,
+            // then re-embed it. This mirrors ListComponent.itemTemplate exactly.
+            const label = template.replace(/<\/?[^>]+(>|$)/g, '');
+            if (!label)
+                return template;
+            return template.replace(label, this.t(label, { _userInput: true }));
+        }
+        // Fall back to the full Select → ListComponent chain for all other cases.
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return super.itemTemplate(data, value, index);
+    }
+    // Disable Choices' fuzzy search and use the deterministic matcher above.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    choicesOptions() {
+        const options = super.choicesOptions();
+        // Force Choices.js client-side searching.
+        // The instance method is replaced in _patchChoicesSearch with the GDS matcher.
+        options.searchChoices = true;
+        options.searchFloor = 0;
+        options.searchFields = ['label', 'value'];
+        // If searchResultLimit is configured too low, raise it to at least limit or 100.
+        const itemLimit = this.component.limit || 100;
+        if (typeof options.searchResultLimit === 'number' && options.searchResultLimit < itemLimit) {
+            options.searchResultLimit = itemLimit;
+        }
+        if (typeof options.renderChoiceLimit === 'number' && options.renderChoiceLimit < itemLimit) {
+            options.renderChoiceLimit = itemLimit;
+        }
+        // formio's default valueComparer is lodash.isEqual — a deep recursive comparison.
+        // choices.js calls this for every choice in the store when resolving which item
+        // is selected (setChoices / _isSelectedByValue). With thousands of object values
+        // {id, name} this produces O(n × depth) recursive comparisons (~5 s).
+        //
+        // For reference-data objects we compare by `id` alone: each port/currency/etc.
+        // has a unique id, so two values are equal iff their ids match — O(1) per call.
+        // Primitives fall back to ===, matching choices.js's own default.
+        options.valueComparer = (a, b) => {
+            if (a === b)
+                return true;
+            if (a == null || b == null)
+                return false;
+            if (typeof a === 'object' && typeof b === 'object') {
+                const aId = a.id;
+                const bId = b.id;
+                if (aId !== undefined && bId !== undefined) {
+                    return aId === bId;
+                }
+            }
+            return false;
+        };
+        return options;
+    }
+}
+exports.default = GDSSelect;

package/lib/components/selectboxes/GDSCheckBoxes.d.ts

@@ -5,3 +5,4 @@ export default class GDSCheckBoxes extends SelectBoxes {
     render(): string;
 }
 export {};
+//# sourceMappingURL=GDSCheckBoxes.d.ts.map

package/lib/components/selectboxes/GDSCheckBoxes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GDSCheckBoxes.d.ts","sourceRoot":"","sources":["../../../src/components/selectboxes/GDSCheckBoxes.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AAGnD,QAAA,MAAM,WAAW,KAAoC,CAAC;AAEtD,MAAM,CAAC,OAAO,OAAO,aAAc,SAAQ,WAAW;IAE1C,SAAS,EAAE,oBAAoB,CAAC;IAEjC,MAAM,IAAI,MAAM;CAS1B"}

package/lib/components/time/GDSTimeComponent.d.ts

@@ -18,3 +18,4 @@ export default class GDSTimeComponent extends Time {
     render(): string;
 }
 export {};
+//# sourceMappingURL=GDSTimeComponent.d.ts.map

package/lib/components/time/GDSTimeComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"GDSTimeComponent.d.ts","sourceRoot":"","sources":["../../../src/components/time/GDSTimeComponent.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAGhD,QAAA,MAAM,IAAI,KAA6B,CAAC;AAExC,MAAM,CAAC,OAAO,OAAO,gBAAiB,SAAQ,IAAI;IAC9C,OAAc,UAAU,SAAK;IAGrB,SAAS,EAAE,iBAAiB,CAAC;IAG7B,IAAI,EAAE;QACV,IAAI,EAAE,gBAAgB,CAAC;QACvB,MAAM,EAAE,gBAAgB,CAAC;KAC5B,CAAC;IAGM,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEtC,OAAO,CAAC,UAAU,CAAgC;IAI3C,MAAM,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAiCnC,eAAe,CAAC,QAAQ,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,GAAG,GAAG,IAAI;IAM/D,aAAa,CAAC,OAAO,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,GAAG,GAAG,IAAI;IAO3D,gBAAgB,CAAC,QAAQ,EAAE,GAAG,GAAG,IAAI;IAKrC,QAAQ,IAAI,MAAM;IAUlB,QAAQ,CAAC,KAAK,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,GAAG,OAAO;IAU1C,MAAM,IAAI,MAAM;CAM1B"}

package/lib/components/time/GDSTimeComponent.js

@@ -14,7 +14,7 @@ class GDSTimeComponent extends Time {
         this.timeHelper = new TimeHelper_1.default();
     }
     // element typed as `any` to match the base component attach(element: any) override signature
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
     attach(element) {
         this.loadRefs(element, {
             hour: 'single',
@@ -41,18 +41,18 @@ class GDSTimeComponent extends Time {
         return super.attach(element);
     }
     // elements typed as `any` to match the base Day.setErrorClasses(elements: any, ...) override signature
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
     setErrorClasses(elements, dirty, hasError) {
         super.setErrorClasses([this.refs.hour, this.refs.minute, ...elements], dirty, hasError);
     }
     // message/dirty/element typed as `any` to match the base Component.addInputError(message: any, dirty: any, elements: any) signature
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
     addInputError(message, dirty, element) {
         super.addInputError(message, dirty, [this.refs.hour, this.refs.minute]);
         super.addInputError(message, dirty, element);
     }
     // elements typed as `any` to match the base Component.removeInputError(elements: any) signature
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
     removeInputError(elements) {
         super.removeInputError([this.refs.hour, this.refs.minute]);
         super.removeInputError(elements);
@@ -65,7 +65,7 @@ class GDSTimeComponent extends Time {
         return (0, moment_1.default)(value, this.component.format).format(this.component.dataFormat);
     }
     // value/flags typed as `any` to match the base Component.setValue(value: any, flags: any) override signature
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
     setValue(value, _flags) {
         if (this.refs.hour && this.refs.minute && value) {
             const parts = value.split(':');

package/lib/components/util/TimeHelper.d.ts

@@ -6,3 +6,4 @@ export default class TimeHelper {
     preventNonNumericKeyPress(evt: KeyboardEvent): void;
     validateDateInput(element: InputElementLike, length: number): void;
 }
+//# sourceMappingURL=TimeHelper.d.ts.map

package/lib/components/util/TimeHelper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TimeHelper.d.ts","sourceRoot":"","sources":["../../../src/components/util/TimeHelper.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE/C,MAAM,CAAC,OAAO,OAAO,UAAU;IAE3B,OAAc,UAAU,SAAK;IAEtB,uBAAuB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAexD,oBAAoB,CAAC,OAAO,EAAE,gBAAgB,GAAG,IAAI;IAgBrD,yBAAyB,CAAC,GAAG,EAAE,aAAa,GAAG,IAAI;IAMnD,iBAAiB,CAAC,OAAO,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;CAK5E"}

package/lib/index.d.ts

@@ -2,7 +2,7 @@ declare const _default: {
     framework: string;
     templates: {
         gds: {
-            transform(type: string, text: string): any;
+            transform(type: string, text: string): string;
             defaultIconset: string;
             iconClass: (iconset: string, name: string, spinning: boolean) => string;
             cssClasses: {
@@ -110,8 +110,10 @@ declare const _default: {
     components: {
         datamap: typeof import("./components/datamap/GDSDataMap").default;
         datetime: typeof import("./components/datetime/GDSDatetimeComponent").default;
+        select: typeof import("./components/select/GDSSelect").default;
         selectboxes: typeof import("./components/selectboxes/GDSCheckBoxes").default;
         time: typeof import("./components/time/GDSTimeComponent").default;
     };
 };
 export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAGA,wBAIE"}

package/lib/templates/gds/button/index.d.ts

@@ -2,3 +2,4 @@ declare const _default: {
     form: string;
 };
 export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/templates/gds/button/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/gds/button/index.ts"],"names":[],"mappings":";;;AAEA,wBAAwB"}

package/lib/templates/gds/checkbox/index.d.ts

@@ -2,3 +2,4 @@ declare const _default: {
     form: string;
 };
 export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/templates/gds/checkbox/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/gds/checkbox/index.ts"],"names":[],"mappings":";;;AAEA,wBAAwB"}

package/lib/templates/gds/columns/index.d.ts

@@ -2,3 +2,4 @@ declare const _default: {
     form: string;
 };
 export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/templates/gds/columns/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/gds/columns/index.ts"],"names":[],"mappings":";;;AAEA,wBAAwB"}

package/lib/templates/gds/component/index.d.ts

@@ -2,3 +2,4 @@ declare const _default: {
     form: string;
 };
 export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/templates/gds/component/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/gds/component/index.ts"],"names":[],"mappings":";;;AAEA,wBAAwB"}

package/lib/templates/gds/container/index.d.ts

@@ -2,3 +2,4 @@ declare const _default: {
     form: string;
 };
 export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/templates/gds/container/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/gds/container/index.ts"],"names":[],"mappings":";;;AAEA,wBAAwB"}

package/lib/templates/gds/cssClasses.d.ts

@@ -12,3 +12,4 @@ declare const _default: {
     'formio-day-component-minute': string;
 };
 export default _default;
+//# sourceMappingURL=cssClasses.d.ts.map

package/lib/templates/gds/cssClasses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cssClasses.d.ts","sourceRoot":"","sources":["../../../src/templates/gds/cssClasses.ts"],"names":[],"mappings":";;;;;;;;;;;;;AAAA,wBAYE"}

package/lib/templates/gds/datagrid/form.ejs.js

@@ -29,7 +29,7 @@ console.warn('Unknown column width for converting to GDS column width: ' +  colu
 columnWidth = 'govuk-grid-column-full';
 }
 ;
-__p += '\n\n<div class="' +
+__p += '\n\n<div class="datagrid-tbody ' +
 ((__t = (ctx.component.customClass)) == null ? '' : __t) +
 '" ref="' +
 ((__t = (ctx.datagridKey)) == null ? '' : __t) +
@@ -99,6 +99,6 @@ __p += '\n    <button class="govuk-button govuk-button--secondary"\n
 ((__t = (ctx.t(ctx.component.addAnother || 'Add Another'))) == null ? '' : __t) +
 '\n    </button>\n    ';
  } ;
-__p += '\n</div>\n\n';
+__p += '\n</div>\n';
 return __p
 }

package/lib/templates/gds/datagrid/index.d.ts

@@ -2,3 +2,4 @@ declare const _default: {
     form: string;
 };
 export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/templates/gds/datagrid/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/gds/datagrid/index.ts"],"names":[],"mappings":";;;AACA,wBAAwB"}

package/lib/templates/gds/datamap/index.d.ts

@@ -2,3 +2,4 @@ declare const _default: {
     form: string;
 };
 export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/templates/gds/datamap/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/gds/datamap/index.ts"],"names":[],"mappings":";;;AAEA,wBAAwB"}

package/lib/templates/gds/datetime/index.d.ts

@@ -2,3 +2,4 @@ declare const _default: {
     form: string;
 };
 export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/templates/gds/datetime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/gds/datetime/index.ts"],"names":[],"mappings":";;;AAEA,wBAAwB"}

package/lib/templates/gds/day/index.d.ts

@@ -2,3 +2,4 @@ declare const _default: {
     form: string;
 };
 export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/templates/gds/day/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/gds/day/index.ts"],"names":[],"mappings":";;;AAEA,wBAAwB"}

package/lib/templates/gds/editgrid/index.d.ts

@@ -2,3 +2,4 @@ declare const _default: {
     form: string;
 };
 export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/templates/gds/editgrid/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/gds/editgrid/index.ts"],"names":[],"mappings":";;;AAEA,wBAAwB"}

package/lib/templates/gds/field/index.d.ts

@@ -2,3 +2,4 @@ declare const _default: {
     form: string;
 };
 export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/templates/gds/field/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/gds/field/index.ts"],"names":[],"mappings":";;;AAEA,wBAAwB"}

package/lib/templates/gds/fieldset/index.d.ts

@@ -2,3 +2,4 @@ declare const _default: {
     form: string;
 };
 export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/templates/gds/fieldset/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/gds/fieldset/index.ts"],"names":[],"mappings":";;;AAEA,wBAAwB"}

package/lib/templates/gds/file/index.d.ts

@@ -2,3 +2,4 @@ declare const _default: {
     form: string;
 };
 export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/templates/gds/file/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/gds/file/index.ts"],"names":[],"mappings":";;;AAEA,wBAAwB"}

package/lib/templates/gds/iconClass.d.ts

@@ -1,2 +1,3 @@
 declare const _default: (iconset: string, name: string, spinning: boolean) => string;
 export default _default;
+//# sourceMappingURL=iconClass.d.ts.map

package/lib/templates/gds/iconClass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"iconClass.d.ts","sourceRoot":"","sources":["../../../src/templates/gds/iconClass.ts"],"names":[],"mappings":"kCAAyB,MAAM,QAAQ,MAAM,YAAY,OAAO,KAAG,MAAM;AAAzE,wBA4BE"}

package/lib/templates/gds/index.d.ts

@@ -1,6 +1,6 @@
 import './template.css';
 declare const _default: {
-    transform(type: string, text: string): any;
+    transform(type: string, text: string): string;
     defaultIconset: string;
     iconClass: (iconset: string, name: string, spinning: boolean) => string;
     cssClasses: {
@@ -105,3 +105,4 @@ declare const _default: {
     };
 };
 export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/templates/gds/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/templates/gds/index.ts"],"names":[],"mappings":"AA0BA,OAAO,gBAAgB,CAAC;;oBAeJ,MAAM,QAAQ,MAAM,GAAG,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AADjD,wBA6CE"}

package/lib/templates/gds/input/index.d.ts

@@ -2,3 +2,4 @@ declare const _default: {
     form: string;
 };
 export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/templates/gds/input/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/gds/input/index.ts"],"names":[],"mappings":";;;AACA,wBAAwB"}

package/lib/templates/gds/label/index.d.ts

@@ -2,3 +2,4 @@ declare const _default: {
     form: string;
 };
 export default _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/templates/gds/label/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/templates/gds/label/index.ts"],"names":[],"mappings":";;;AACA,wBAAwB"}