@sitecore-content-sdk/content 1.5.0-canary.5

package/dist/esm/editing/design-library.js

@@ -0,0 +1,172 @@
+import { constants } from '@sitecore-content-sdk/core';
+import { normalizeUrl } from '@sitecore-content-sdk/core/tools';
+import { DesignLibraryMode } from './models';
+const { SITECORE_EDGE_URL_DEFAULT } = constants;
+/**
+ * Event to be sent when report status to design library
+ */
+const DESIGN_LIBRARY_STATUS_EVENT_NAME = 'component:status';
+/**
+ * Prefix for component update cache keys
+ * @internal
+ */
+export const COMPONENT_UPDATE_CACHE_KEY_PREFIX = 'component-update-';
+/**
+ * Enumeration of statuses for the design library.
+ * @internal
+ */
+export var DesignLibraryStatus;
+(function (DesignLibraryStatus) {
+    DesignLibraryStatus["READY"] = "ready";
+    DesignLibraryStatus["RENDERED"] = "rendered";
+})(DesignLibraryStatus || (DesignLibraryStatus = {}));
+/**
+ * Adds the browser-side event handler for 'component:update' message used in Design Library
+ * The event should update a component on page by uid, with fields and params from event args
+ * @param {ComponentRendering} rootComponent root component displayed for Design Library page
+ * @param {Function} successCallback  callback to be called after successful component update
+ * @internal
+ */
+export const addComponentUpdateHandler = (rootComponent, successCallback) => {
+    if (!window)
+        return;
+    const handler = (e) => updateComponentHandler(e, rootComponent, successCallback);
+    window.addEventListener('message', handler);
+    // the power to remove handler outside of this function, if needed
+    const unsubscribe = () => {
+        window.removeEventListener('message', handler);
+    };
+    return unsubscribe;
+};
+export const validateOrigin = (event) => {
+    // TODO: use `EDITING_ALLOWED_ORIGINS.concat(getAllowedOriginsFromEnv())` later
+    // nextjs's JSS_ALLOWED_ORIGINS is not available on the client, need to use NEXT_PUBLIC_ variable, but it's a breaking change for Deploy
+    const allowedOrigins = ['*'];
+    return allowedOrigins.some((origin) => origin === event.origin ||
+        new RegExp('^' + origin.replace('.', '\\.').replace(/\*/g, '.*') + '$').test(event.origin));
+};
+/**
+ * Validates that a MessageEvent has the expected event name and required data.
+ * Logs debug information when validation fails due to invalid origin.
+ * @param {MessageEvent} e - The message event to validate.
+ * @param {string} eventName - The expected event name to match against e.data.name.
+ * @returns {boolean} True if the event has a valid origin, data object, and matching event name; otherwise false.
+ */
+export const validateEvent = (e, eventName) => {
+    if (!e.origin || !e.data || e.data.name !== eventName) {
+        // avoid extra noise in logs
+        if (!validateOrigin(e)) {
+            console.debug('Component Library: event skipped - invalid origin: message %s from origin %s', e.data.name, e.origin);
+        }
+        return false;
+    }
+    return true;
+};
+export const updateComponentHandler = (e, rootComponent, successCallback) => {
+    var _a;
+    const eventArgs = e.data;
+    if (!e.origin || !eventArgs || eventArgs.name !== 'component:update') {
+        // avoid extra noise in logs
+        if (!validateOrigin(e)) {
+            console.debug('Component Library: event skipped: message %s from origin %s', eventArgs.name, e.origin);
+        }
+        return;
+    }
+    if (!((_a = eventArgs.details) === null || _a === void 0 ? void 0 : _a.uid)) {
+        console.debug('Received component:update event without uid, aborting event handler...');
+        return;
+    }
+    const findComponent = (root) => {
+        var _a, _b;
+        if (((_a = root.uid) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === ((_b = eventArgs.details) === null || _b === void 0 ? void 0 : _b.uid.toLowerCase()))
+            return root;
+        if (root.placeholders) {
+            for (const plhName of Object.keys(root.placeholders)) {
+                for (const rendering of root.placeholders[plhName]) {
+                    const result = findComponent(rendering);
+                    if (result)
+                        return result;
+                }
+            }
+        }
+        return null;
+    };
+    const componentToUpdate = findComponent(rootComponent);
+    if (componentToUpdate) {
+        console.debug('Found component with uid %s to update. Update fields: %o. Update params: %o.', eventArgs.details.uid, eventArgs.details.fields, eventArgs.details.params);
+        updateComponent(componentToUpdate, eventArgs.details.fields, eventArgs.details.params);
+        if (successCallback)
+            successCallback(rootComponent);
+    }
+    else {
+        console.debug('Rendering with uid %s not found', eventArgs.details.uid);
+    }
+    // strictly for testing
+    return rootComponent;
+};
+/**
+ * Updates a component's fields and params with the provided values.
+ * @param {ComponentRendering<ComponentFields>} component - The component to update.
+ * @param {ComponentFields | undefined} fields - The fields to merge into the component.
+ * @param {ComponentParams | undefined} params - The params to merge into the component.
+ * @internal
+ */
+export const updateComponent = (component, fields, params) => {
+    if (fields) {
+        component.fields = Object.assign(Object.assign({}, component.fields), fields);
+    }
+    if (params) {
+        component.params = Object.assign(Object.assign({}, component.params), params);
+    }
+};
+/**
+ * Generates a DesignLibraryStatusEvent with the given status and uid.
+ * @param {DesignLibraryStatus} status - The status of rendering.
+ * @param {string} uid - The unique identifier for the event.
+ * @returns An object representing the DesignLibraryStatusEvent.
+ * @internal
+ */
+export function getDesignLibraryStatusEvent(status, uid) {
+    return {
+        name: DESIGN_LIBRARY_STATUS_EVENT_NAME,
+        message: {
+            status,
+            uid,
+        },
+    };
+}
+/**
+ * Generates the URL for the design library script link.
+ * @param {string} [sitecoreEdgeUrl] Sitecore Edge Platform URL. Default is https://edge-platform.sitecorecloud.io
+ * @returns The full URL to the design library script.
+ * @internal
+ */
+export function getDesignLibraryScriptLink(sitecoreEdgeUrl = SITECORE_EDGE_URL_DEFAULT) {
+    return `${normalizeUrl(sitecoreEdgeUrl)}/v1/files/designlibrary/lib/rh-lib-script.js`;
+}
+/**
+ * Checks if the given mode is a Design Library mode.
+ * @param {unknown} mode - The mode to check.
+ * @returns {boolean} True if the mode is a Design Library mode, false otherwise.
+ * @internal
+ */
+export function isDesignLibraryMode(mode) {
+    return mode === DesignLibraryMode.Normal || mode === DesignLibraryMode.Metadata;
+}
+/**
+ * Sends an event to the Design Library
+ * @param {DesignLibraryEvent} evt - The event object to send.
+ * @internal
+ */
+export const postToDesignLibrary = (evt) => {
+    if (typeof window === 'undefined')
+        return;
+    const target = window.parent && window.parent !== window ? window.parent : window;
+    try {
+        console.log('Component Library: sending event', evt.name, evt);
+        target.postMessage(evt, '*');
+    }
+    catch (err) {
+        console.error('Component Library: postMessage failed', err, evt);
+    }
+};

package/dist/esm/editing/editing-service.js

@@ -0,0 +1,74 @@
+import debug from '../debug';
+import { LayoutKind } from './models';
+/**
+ * GraphQL query for fetching editing data.
+ */
+export const query = /* GraphQL */ `
+  query EditingQuery($itemId: String!, $language: String!, $version: String) {
+    item(path: $itemId, language: $language, version: $version) {
+      rendered
+    }
+  }
+`;
+/**
+ * Service for fetching editing data from Sitecore using the Sitecore's GraphQL API.
+ * Expected to be used in XMCloud Pages preview (editing) Metadata Edit Mode.
+ * @public
+ */
+export class EditingService {
+    /**
+     * Fetch layout data using the Sitecore GraphQL endpoint.
+     * @param {EditingServiceConfig} serviceConfig configuration
+     */
+    constructor(serviceConfig) {
+        this.serviceConfig = serviceConfig;
+        this.graphQLClient = this.getGraphQLClient();
+    }
+    /**
+     * Fetches editing data. Provides the layout data and dictionary phrases
+     * @param {object} variables - The parameters for fetching editing data.
+     * @param {string} variables.itemId - The item id (path) to fetch layout data for.
+     * @param {string} variables.language - The language to fetch layout data for.
+     * @param {string} variables.mode - The editing mode to fetch layout data for.
+     * @param {string} [variables.version] - The version of the item (optional).
+     * @param {LayoutKind} [variables.layoutKind] - The final or shared layout variant.
+     * @param {FetchOptions} [fetchOptions] Options to override graphQL client details like retries and fetch implementation
+     * @returns {Promise} The layout data and dictionary phrases.
+     */
+    async fetchEditingData({ itemId, language, version, layoutKind = LayoutKind.Final, mode }, fetchOptions) {
+        var _a;
+        debug.editing('fetching editing data for %s %s %s %s', itemId, language, version, layoutKind);
+        if (!language) {
+            throw new RangeError('The language must be a non-empty string');
+        }
+        const editModeHeader = mode === 'edit' ? 'true' : 'false';
+        const editingData = await this.graphQLClient.request(query, {
+            itemId,
+            version,
+            language,
+        }, Object.assign(Object.assign({}, fetchOptions), { headers: {
+                sc_layoutKind: layoutKind,
+                sc_editMode: editModeHeader,
+            } }));
+        return {
+            layoutData: ((_a = editingData === null || editingData === void 0 ? void 0 : editingData.item) === null || _a === void 0 ? void 0 : _a.rendered) || {
+                sitecore: {
+                    context: { pageEditing: true, language },
+                    route: null,
+                },
+            },
+        };
+    }
+    /**
+     * Gets a GraphQL client that can make requests to the API.
+     * @returns {GraphQLClient} implementation
+     */
+    getGraphQLClient() {
+        if (!this.serviceConfig.clientFactory) {
+            throw new Error('clientFactory needs to be provided when initializing GraphQL client.');
+        }
+        return this.serviceConfig.clientFactory({
+            debugger: debug.editing,
+        });
+    }
+}

package/dist/esm/editing/index.js

@@ -0,0 +1,6 @@
+export { EditingService } from './editing-service';
+export { DEFAULT_PLACEHOLDER_UID, PagesEditor, isEditorActive, resetEditorChromes, getContentSdkPagesClientData, EDITING_ALLOWED_ORIGINS, QUERY_PARAM_EDITING_SECRET, INVALID_SECRET_HTML_MESSAGE, PAGES_EDITING_MARKER, PREVIEW_KEY, } from './utils';
+export { ComponentLayoutService, } from './component-layout-service';
+export { DesignLibraryVariantGeneration, } from './models';
+export { LayoutKind, MetadataKind, DesignLibraryMode, } from './models';
+export { addComponentUpdateHandler, DesignLibraryStatus, getDesignLibraryStatusEvent, getDesignLibraryScriptLink, isDesignLibraryMode, postToDesignLibrary, COMPONENT_UPDATE_CACHE_KEY_PREFIX, updateComponent, } from './design-library';

package/dist/esm/editing/models.js

@@ -0,0 +1,41 @@
+/**
+ * Represents the Editing Layout variant.
+ * - shared - shared layout
+ * - final - final layout
+ * @public
+ */
+export var LayoutKind;
+(function (LayoutKind) {
+    LayoutKind["Final"] = "final";
+    LayoutKind["Shared"] = "shared";
+})(LayoutKind || (LayoutKind = {}));
+/**
+ * Represents the kind of metadata element.
+ * - open - starting chrome element
+ * - close - closing chrome element
+ * @internal
+ */
+export var MetadataKind;
+(function (MetadataKind) {
+    MetadataKind["Open"] = "open";
+    MetadataKind["Close"] = "close";
+})(MetadataKind || (MetadataKind = {}));
+/**
+ * Represents the mode of the Design Library
+ * @public
+ */
+export var DesignLibraryMode;
+(function (DesignLibraryMode) {
+    /** Normal mode */
+    DesignLibraryMode["Normal"] = "library";
+    /** Metadata mode */
+    DesignLibraryMode["Metadata"] = "library-metadata";
+})(DesignLibraryMode || (DesignLibraryMode = {}));
+/**
+ * Variant generation mode for Design Library
+ * @public
+ */
+export var DesignLibraryVariantGeneration;
+(function (DesignLibraryVariantGeneration) {
+    DesignLibraryVariantGeneration["Variant"] = "variant";
+})(DesignLibraryVariantGeneration || (DesignLibraryVariantGeneration = {}));

package/dist/esm/editing/utils.js

@@ -0,0 +1,98 @@
+import { isServer } from '@sitecore-content-sdk/core/tools';
+/**
+ * Default value of uid for root placeholder when uid is not present.
+ * @internal
+ */
+export const DEFAULT_PLACEHOLDER_UID = '00000000-0000-0000-0000-000000000000';
+/**
+ * Query parameter for editing secret
+ * @internal
+ */
+export const QUERY_PARAM_EDITING_SECRET = 'secret';
+/**
+ * HTML returned for invalid or missing secret
+ * @internal
+ */
+export const INVALID_SECRET_HTML_MESSAGE = '<html><body>Missing or invalid secret</body></html>';
+/**
+ * Key to identify whether the app is running in Sitecore Preview mode
+ * @internal
+ */
+export const PREVIEW_KEY = 'sc_preview';
+/**
+ * ID to be used as a marker for a script rendered in XMC Pages
+ * Should identify app is in XM Cloud Pages editing mode
+ * @internal
+ */
+export const PAGES_EDITING_MARKER = 'jss-hrz-editing';
+/**
+ * Default allowed origins for editing requests. This is used to enforce CORS, CSP headers.
+ * @internal
+ */
+export const EDITING_ALLOWED_ORIGINS = [
+    'https://pages.sitecorecloud.io',
+    'https://xmapps.sitecorecloud.io',
+    'https://designlibrary.sitecorecloud.io',
+];
+/**
+ * Copy of chrome rediscovery contract from Horizon (chrome-rediscovery.contract.ts)
+ */
+export const ChromeRediscoveryGlobalFunctionName = {
+    name: 'Sitecore.Horizon.ResetChromes',
+};
+/**
+ * Static utility class for Sitecore Pages Editor
+ * @public
+ */
+export class PagesEditor {
+    /**
+     * Determines whether the current execution context is within a Pages Editor.
+     * Pages Editor environment can be identified only in the browser
+     * @returns true if executing within a Pages Editor
+     */
+    static isActive() {
+        if (isServer()) {
+            return false;
+        }
+        // Check for Chromes mode
+        const chromesCheck = window.location.search.indexOf('sc_headless_mode=edit') > -1;
+        // Content SDK will render a content-sdk-exclusive script element in Metadata mode to indicate edit mode in Pages
+        return chromesCheck || !!window.document.getElementById(PAGES_EDITING_MARKER);
+    }
+    static resetChromes() {
+        if (isServer()) {
+            return;
+        }
+        // Reset chromes in Pages
+        window[ChromeRediscoveryGlobalFunctionName.name] &&
+            window[ChromeRediscoveryGlobalFunctionName.name]();
+    }
+}
+/**
+ * Determines whether the current execution context is within a Sitecore editor.
+ * Sitecore Editor environment can be identified only in the browser
+ * @returns true if executing within a Sitecore editor
+ * @public
+ */
+export const isEditorActive = () => {
+    return PagesEditor.isActive();
+};
+/**
+ * Resets Sitecore editor "chromes"
+ * @public
+ */
+export const resetEditorChromes = () => {
+    if (PagesEditor.isActive()) {
+        PagesEditor.resetChromes();
+    }
+};
+/**
+ * Gets extra Content SDK clientData scripts to render in XMC Pages in addition to clientData from Pages itself
+ * @returns {Record} collection of clientData
+ * @internal
+ */
+export const getContentSdkPagesClientData = () => {
+    const clientData = {};
+    clientData[PAGES_EDITING_MARKER] = {};
+    return clientData;
+};

package/dist/esm/form/form.js

@@ -0,0 +1,72 @@
+import { form } from '@sitecore-cloudsdk/events/browser';
+import { getEdgeProxyFormsUrl } from '../client';
+import debug from '../debug';
+/**
+ * Fetches the form markup from the Sitecore Edge service and renders it in the component's template.
+ * @param {string} contextId - The unique identifier of the current context
+ * @param {string} formId - The unique identifier of the form
+ * @param {string} [edgeUrl] - The URL of the Sitecore Edge Platform
+ * @internal
+ */
+export const loadForm = async (contextId, formId, edgeUrl) => {
+    if (!contextId) {
+        debug.form('Form was not able to render since context id was not provided');
+        return '';
+    }
+    const url = getEdgeProxyFormsUrl(contextId, formId, edgeUrl);
+    try {
+        debug.form(`Fetching form data from ${url}`);
+        const rsp = await fetch(url, {
+            method: 'GET',
+            cache: 'no-cache',
+        });
+        if (rsp.status !== 200) {
+            throw new Error('Failed to fetch form data');
+        }
+        const content = await rsp.text();
+        debug.form(`Form data fetch response: ${content}`);
+        return content;
+    }
+    catch (error) {
+        debug.form(`Form '${formId}' was not able to render`, error);
+        throw error;
+    }
+};
+/**
+ * When you set the innerHTML property of an element, the browser does not execute any <script> tags included in the HTML string
+ * This method ensures that any <script> elements within the loaded HTML are executed.
+ * It re-creates the script elements and appends the to the component's template, then removes old script elements to avoid duplication.
+ * @param {HTMLElement} rootElement - The root element to execute script elements within
+ * @internal
+ */
+export const executeScriptElements = (rootElement) => {
+    const scriptElements = rootElement.querySelectorAll('script');
+    if (!scriptElements) {
+        return;
+    }
+    Array.from(scriptElements).forEach((scriptElement) => {
+        var _a;
+        const clonedElement = document.createElement('script');
+        Array.from(scriptElement.attributes).forEach((attribute) => {
+            clonedElement.setAttribute(attribute.name, attribute.value);
+        });
+        clonedElement.text = scriptElement.text;
+        (_a = scriptElement === null || scriptElement === void 0 ? void 0 : scriptElement.parentNode) === null || _a === void 0 ? void 0 : _a.replaceChild(clonedElement, scriptElement);
+    });
+};
+/**
+ * Subscribes to the Form event
+ * This listener captures interactions such as form views or submissions
+ * @param {HTMLElement} formElement - The form element to subscribe to events on
+ * @param {string} [componentId] - The unique identifier of the component
+ * @internal
+ */
+export const subscribeToFormSubmitEvent = (formElement, componentId) => {
+    formElement.addEventListener('form:engage', ((e) => {
+        const { formId, name } = e.detail;
+        if (formId && name) {
+            debug.form('Sending form event', formId, name);
+            form(formId, name, (componentId === null || componentId === void 0 ? void 0 : componentId.replace(/-/g, '')) || '');
+        }
+    }));
+};

package/dist/esm/form/index.js

@@ -0,0 +1 @@
+export { executeScriptElements, loadForm, subscribeToFormSubmitEvent } from './form';

package/dist/esm/i18n/dictionary-service.js

@@ -0,0 +1,137 @@
+import { MemoryCacheClient, } from '@sitecore-content-sdk/core';
+import { siteNameError, languageError } from '../constants';
+import debug from '../debug';
+/** @private */
+export const queryError = 'Valid value for rootItemId not provided and failed to auto-resolve app root item.';
+/** @default */
+const siteQuery = /* GraphQL */ `
+  query DictionarySiteQuery(
+    $siteName: String!
+    $language: String!
+    $pageSize: Int = 500
+    $after: String
+  ) {
+    site {
+      siteInfo(site: $siteName) {
+        dictionary(language: $language, first: $pageSize, after: $after) {
+          pageInfo {
+            endCursor
+            hasNext
+          }
+          results {
+            key
+            value
+          }
+        }
+      }
+    }
+  }
+`;
+/**
+ * Service that fetch dictionary data using Sitecore's GraphQL API.
+ * @augments DictionaryServiceBase
+ * @mixes SearchQueryService<DictionaryQueryResult>
+ * @public
+ */
+export class DictionaryService {
+    /**
+     * Creates an instance of graphQL dictionary service with the provided options
+     * @param {DictionaryService} options instance
+     */
+    constructor(options) {
+        this.options = options;
+        this.cache = this.getCacheClient();
+        this.graphQLClient = this.getGraphQLClient();
+    }
+    /**
+     * Fetches dictionary data for internalization. Uses search query by default
+     * @param {string} language the language to fetch
+     * @param {string} site site name to fetch data for.
+     * @param {FetchOptions} [fetchOptions] Options to override graphQL client details like retries and fetch implementation
+     * @returns {Promise<DictionaryPhrases>} dictionary phrases
+     * @throws {Error} if the app root was not found for the specified site and language.
+     */
+    async fetchDictionaryData(language, site, fetchOptions) {
+        var _a, _b;
+        const cacheKey = site + language;
+        const cachedValue = this.getCacheValue(cacheKey);
+        if (cachedValue) {
+            debug.dictionary('using cached dictionary data for %s %s', language, site);
+            return cachedValue;
+        }
+        const phrases = {};
+        debug.dictionary('fetching dictionary data for %s %s', language, site);
+        let results = [];
+        let hasNext = true;
+        let after = '';
+        if (!site) {
+            throw new RangeError(siteNameError);
+        }
+        if (!language) {
+            throw new RangeError(languageError);
+        }
+        while (hasNext) {
+            const fetchResponse = await this.graphQLClient.request(siteQuery, {
+                siteName: site,
+                language,
+                pageSize: this.options.pageSize,
+                after,
+            }, fetchOptions);
+            if ((_b = (_a = fetchResponse === null || fetchResponse === void 0 ? void 0 : fetchResponse.site) === null || _a === void 0 ? void 0 : _a.siteInfo) === null || _b === void 0 ? void 0 : _b.dictionary) {
+                results = results.concat(fetchResponse.site.siteInfo.dictionary.results);
+                after = fetchResponse.site.siteInfo.dictionary.pageInfo.endCursor;
+                hasNext = fetchResponse.site.siteInfo.dictionary.pageInfo.hasNext;
+            }
+            else {
+                hasNext = false;
+            }
+        }
+        results.forEach((item) => (phrases[item.key] = item.value));
+        this.setCacheValue(cacheKey, phrases);
+        return phrases;
+    }
+    /**
+     * Caches a @see DictionaryPhrases value for the specified cache key.
+     * @param {string} key The cache key.
+     * @param {DictionaryPhrases} value The value to cache.
+     * @returns The value added to the cache.
+     * @mixes CacheClient<DictionaryPhrases>
+     */
+    setCacheValue(key, value) {
+        return this.cache.setCacheValue(key, value);
+    }
+    /**
+     * Retrieves a @see DictionaryPhrases value from the cache.
+     * @param {string} key The cache key.
+     * @returns The @see DictionaryPhrases value, or null if the specified key is not found in the cache.
+     */
+    getCacheValue(key) {
+        return this.cache.getCacheValue(key);
+    }
+    /**
+     * Gets a cache client that can cache data. Uses memory-cache as the default
+     * library for caching (@see MemoryCacheClient). Override this method if you
+     * want to use something else.
+     * @returns {CacheClient} implementation
+     */
+    getCacheClient() {
+        return new MemoryCacheClient(this.options);
+    }
+    /**
+     * Gets a GraphQL client that can make requests to the API. Uses graphql-request as the default
+     * library for fetching graphql data (@see GraphQLRequestClient). Override this method if you
+     * want to use something else.
+     * @returns {GraphQLClient} implementation
+     */
+    getGraphQLClient() {
+        var _a, _b;
+        if (!this.options.clientFactory) {
+            throw new Error('clientFactory needs to be provided when initializing GraphQL client.');
+        }
+        return this.options.clientFactory({
+            debugger: debug.dictionary,
+            retries: (_a = this.options.retries) === null || _a === void 0 ? void 0 : _a.count,
+            retryStrategy: (_b = this.options.retries) === null || _b === void 0 ? void 0 : _b.retryStrategy,
+        });
+    }
+}

package/dist/esm/i18n/index.js

@@ -0,0 +1,2 @@
+export { DictionaryService, } from './dictionary-service';
+export { getLocaleRewrite } from './utils';

package/dist/esm/i18n/utils.js

@@ -0,0 +1,13 @@
+/**
+ * Get a locale rewrite path for given pathname
+ * @param {string} pathname the pathname
+ * @param {string} locale the site data to include in the rewrite
+ * @returns {string} the rewrite path
+ * @public
+ */
+export function getLocaleRewrite(pathname, locale) {
+    if (pathname === '/')
+        return `/${locale}`;
+    const path = pathname.startsWith('/') ? pathname : '/' + pathname;
+    return `/${locale}${path}`;
+}

package/dist/esm/index.js

@@ -0,0 +1,5 @@
+import * as form from './form';
+export { default as debug } from './debug';
+export { form };
+export { defineConfig } from './config';
+export { HIDDEN_RENDERING_NAME } from './constants';