@wavemaker-ai/react-runtime 1.0.0-next.27766

package/store/viewport.service.d.ts

@@ -0,0 +1,45 @@
+import EventNotifier from "@/core/event-notifier";
+export declare const enum ViewportEvent {
+    ORIENTATION_CHANGE = "orientationchange",
+    RESIZE = "resize"
+}
+export interface IViewportService {
+    notify: (eventname: ViewportEvent, options?: Array<any>) => void;
+    subscribe: (eventname: ViewportEvent, callback: (data: any) => void) => () => void;
+}
+export declare class ViewportService implements IViewportService {
+    orientation: {
+        isPortrait: boolean;
+        isLandscape: boolean;
+    };
+    isMobileType: boolean;
+    isTabletType: boolean;
+    private type;
+    _eventNotifier: EventNotifier;
+    private screenWidth;
+    private screenHeight;
+    private selectedViewPort;
+    private boundResizeFn;
+    constructor();
+    update(selectedViewPort: object): void;
+    private orientationChange;
+    private resizeFn;
+    subscribe(eventName: string, callback: (data: any) => void): () => void;
+    notify(eventName: string, ...data: Array<any>): void;
+    private setScreenType;
+    getViewport(): {
+        screenWidth: number;
+        screenHeight: number;
+        windowWidth: number;
+        windowHeight: number;
+        isMobile: boolean;
+        isTablet: boolean;
+        isDesktop: boolean;
+        orientation: {
+            isPortrait: boolean;
+            isLandscape: boolean;
+        };
+    };
+    destroy(): void;
+}
+export declare const viewportService: ViewportService;

package/store/viewport.service.js

@@ -0,0 +1,211 @@
+"use client";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import EventNotifier from "../core/event-notifier";
+import get from "lodash-es/get";
+let MINIMUM_MOBILE_WIDTH = 480;
+let MINIMUM_TAB_WIDTH = 768;
+let MINIMUM_LARGE_SCREEN_WIDTH = 1200;
+var SCREEN_TYPE = /* @__PURE__ */ ((SCREEN_TYPE2) => {
+  SCREEN_TYPE2[SCREEN_TYPE2["MOBILE"] = 0] = "MOBILE";
+  SCREEN_TYPE2[SCREEN_TYPE2["TABLET"] = 1] = "TABLET";
+  SCREEN_TYPE2[SCREEN_TYPE2["LARGE_SCREEN_DEVICES"] = 2] = "LARGE_SCREEN_DEVICES";
+  return SCREEN_TYPE2;
+})(SCREEN_TYPE || {});
+var ViewportEvent = /* @__PURE__ */ ((ViewportEvent2) => {
+  ViewportEvent2["ORIENTATION_CHANGE"] = "orientationchange";
+  ViewportEvent2["RESIZE"] = "resize";
+  return ViewportEvent2;
+})(ViewportEvent || {});
+const isAndroid = () => {
+  if (typeof navigator === "undefined") return false;
+  return /Android/i.test(navigator.userAgent);
+};
+const isAndroidTablet = () => {
+  if (typeof navigator === "undefined") return false;
+  return /android|android 3.0|xoom|sch-i800|playbook|tablet|kindle/i.test(navigator.userAgent);
+};
+const isIos = () => {
+  if (typeof navigator === "undefined") return false;
+  return /iPad|iPhone|iPod/.test(navigator.userAgent);
+};
+class ViewportService {
+  constructor() {
+    __publicField(this, "orientation", {
+      isPortrait: false,
+      isLandscape: false
+    });
+    __publicField(this, "isMobileType", false);
+    __publicField(this, "isTabletType", false);
+    __publicField(this, "type");
+    __publicField(this, "_eventNotifier", new EventNotifier());
+    __publicField(this, "screenWidth", 0);
+    __publicField(this, "screenHeight", 0);
+    __publicField(this, "selectedViewPort");
+    __publicField(this, "boundResizeFn", null);
+    if (typeof window === "undefined") return;
+    this.setScreenType();
+    this.boundResizeFn = this.resizeFn.bind(this);
+    window.addEventListener("resize" /* RESIZE */, this.boundResizeFn);
+    const query = window.matchMedia("(orientation: portrait)");
+    if (query.matches) {
+      this.orientation.isPortrait = true;
+    } else {
+      this.orientation.isLandscape = true;
+    }
+    if (query.addEventListener) {
+      query.addEventListener(
+        "change",
+        ($event) => this.orientationChange($event, !$event.matches)
+      );
+    } else if (query.addListener) {
+      query.addListener(
+        ($event) => this.orientationChange($event, !$event.matches)
+      );
+    }
+  }
+  update(selectedViewPort) {
+    this.selectedViewPort = selectedViewPort;
+    this.setScreenType();
+  }
+  orientationChange($event, isLandscape) {
+    if (isLandscape !== this.orientation.isLandscape) {
+      this.orientation.isPortrait = !isLandscape;
+      this.orientation.isLandscape = isLandscape;
+      this.notify("orientationchange" /* ORIENTATION_CHANGE */, {
+        $event,
+        data: { isPortrait: !isLandscape, isLandscape }
+      });
+    }
+  }
+  resizeFn($event) {
+    const $el = document.querySelector(".wm-app");
+    if (!$el) {
+      return;
+    }
+    this.setScreenType();
+    this.orientationChange($event, this.screenWidth >= this.screenHeight);
+    this.notify("resize" /* RESIZE */, {
+      $event,
+      data: { screenWidth: this.screenWidth, screenHeight: this.screenHeight }
+    });
+  }
+  subscribe(eventName, callback) {
+    return this._eventNotifier.subscribe(eventName, callback);
+  }
+  notify(eventName, ...data) {
+    this._eventNotifier.notify(eventName, data);
+  }
+  setScreenType() {
+    if (typeof window === "undefined") {
+      return;
+    }
+    const $el = document.querySelector(".wm-app");
+    if (!$el) return;
+    this.screenWidth = $el.clientWidth;
+    this.screenHeight = $el.clientHeight;
+    this.isTabletType = false;
+    this.isMobileType = false;
+    if (get(this.selectedViewPort, "deviceCategory")) {
+      const deviceCategory = this.selectedViewPort.deviceCategory;
+      if (deviceCategory === "Tab") {
+        this.isTabletType = true;
+      } else if (deviceCategory === "Smartphone") {
+        this.isMobileType = true;
+      }
+    } else {
+      MINIMUM_MOBILE_WIDTH = parseInt(getComputedStyle(document.documentElement).getPropertyValue("--screen-xs")) || 480;
+      MINIMUM_TAB_WIDTH = parseInt(getComputedStyle(document.documentElement).getPropertyValue("--screen-sm")) || 768;
+      MINIMUM_LARGE_SCREEN_WIDTH = parseInt(getComputedStyle(document.documentElement).getPropertyValue("--screen-lg")) || 1200;
+      if (this.screenWidth >= MINIMUM_LARGE_SCREEN_WIDTH) {
+        this.isTabletType = isAndroid() || isIos() || isAndroidTablet();
+        this.isMobileType = false;
+      } else if (this.screenWidth >= MINIMUM_TAB_WIDTH) {
+        this.type = 1 /* TABLET */;
+        this.isTabletType = true;
+      } else {
+        this.type = 0 /* MOBILE */;
+        this.isMobileType = true;
+      }
+    }
+  }
+  getViewport() {
+    return {
+      screenWidth: this.screenWidth,
+      screenHeight: this.screenHeight,
+      windowWidth: typeof window !== "undefined" ? window.innerWidth : 0,
+      windowHeight: typeof window !== "undefined" ? window.innerHeight : 0,
+      isMobile: this.isMobileType,
+      isTablet: this.isTabletType,
+      isDesktop: !this.isMobileType && !this.isTabletType,
+      orientation: this.orientation
+    };
+  }
+  destroy() {
+    this._eventNotifier.destroy();
+    if (typeof window !== "undefined" && this.boundResizeFn) {
+      window.removeEventListener("resize", this.boundResizeFn);
+    }
+  }
+}
+let viewportServiceInstance = null;
+const createSSRStub = () => {
+  const stub = {
+    orientation: { isPortrait: false, isLandscape: false },
+    isMobileType: false,
+    isTabletType: false,
+    type: void 0,
+    _eventNotifier: new EventNotifier(),
+    screenWidth: 0,
+    screenHeight: 0,
+    selectedViewPort: void 0,
+    boundResizeFn: null,
+    subscribe: () => () => {
+    },
+    notify: () => {
+    },
+    update: () => {
+    },
+    getViewport: () => ({
+      screenWidth: 0,
+      screenHeight: 0,
+      windowWidth: 0,
+      windowHeight: 0,
+      isMobile: false,
+      isTablet: false,
+      isDesktop: true,
+      orientation: { isPortrait: false, isLandscape: false }
+    }),
+    destroy: () => {
+    }
+  };
+  return stub;
+};
+function getViewportService() {
+  if (typeof window === "undefined") {
+    if (!viewportServiceInstance) {
+      viewportServiceInstance = createSSRStub();
+    }
+    return viewportServiceInstance;
+  }
+  if (!viewportServiceInstance) {
+    viewportServiceInstance = new ViewportService();
+  }
+  return viewportServiceInstance;
+}
+const viewportService = new Proxy({}, {
+  get(_target, prop) {
+    const service = getViewportService();
+    const value = service[prop];
+    if (typeof value === "function") {
+      return value.bind(service);
+    }
+    return value;
+  }
+});
+export {
+  ViewportEvent,
+  ViewportService,
+  viewportService
+};

package/types/index.d.ts

@@ -0,0 +1,70 @@
+export interface Config {
+    serviceDefs?: Record<string, any>;
+    appConfig: {
+        url: string;
+    };
+    appVariables: any;
+}
+export interface PageContextState {
+    Widgets: Record<string, any>;
+    Variables: Record<string, VariableState>;
+    Actions: Record<string, any>;
+    onReady: () => void;
+    pageReady: () => void;
+    serviceDefinitions: Record<string, any>;
+    baseUrl: string;
+    [key: string]: any;
+}
+export interface VariableState {
+    loading: boolean;
+    error: any;
+    data: any;
+    invokeOnParamChange?: Function;
+}
+export interface ProxyTarget {
+    [key: string]: any;
+}
+export interface MockApp {
+    getDependency: (name: string) => null;
+    appConfig: any;
+    Variables: Record<string, any>;
+    Actions: Record<string, any>;
+    serviceDefinitions: Record<string, any>;
+    baseUrl: string;
+    reload: () => void;
+    changeLocale: (locale: string) => void;
+    selectedLocale: string;
+}
+export type WithPageContextProps<P> = P & {
+    config?: Config;
+    [key: string]: any;
+};
+export declare enum VariableEvents {
+    BEFORE_INVOKE = "beforeInvoke",
+    SUCCESS = "success",
+    ERROR = "error",
+    AFTER_INVOKE = "afterInvoke"
+}
+export interface Subscription {
+    variable: any;
+    event: VariableEvents;
+    handler: () => void;
+}
+export interface CommonComponentInfo {
+    component: React.ComponentType<any>;
+}
+export type ComponentInfo = {
+    componentName: string;
+    componentType: "PAGE" | "PARTIAL" | "PREFAB";
+    appLocale: Record<string, unknown>;
+    startUpVariables: string[];
+    startUpActions: string[];
+    autoUpdateVariables: string[];
+    /**
+     * Dependency paths this component reads cross-context from the active page, e.g.
+     * `Variables.PageDataInvoke1.dataSet.content` or `Widgets.button1.caption`. Declared at codegen
+     * time; the runtime value-gates re-renders to exactly these when the active page changes.
+     */
+    activePageDeps?: string[];
+    isPartOfPrefab: boolean;
+};

package/types/index.js

@@ -0,0 +1,10 @@
+var VariableEvents = /* @__PURE__ */ ((VariableEvents2) => {
+  VariableEvents2["BEFORE_INVOKE"] = "beforeInvoke";
+  VariableEvents2["SUCCESS"] = "success";
+  VariableEvents2["ERROR"] = "error";
+  VariableEvents2["AFTER_INVOKE"] = "afterInvoke";
+  return VariableEvents2;
+})(VariableEvents || {});
+export {
+  VariableEvents
+};

package/utils/attr.d.ts

@@ -0,0 +1 @@
+export declare const removeInvalidAttributes: (attributes: Record<string, any>, explicitRemoveAttributes?: string[]) => Record<string, any>;

package/utils/attr.js

@@ -0,0 +1,244 @@
+const INTERNAL_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "clearSearch",
+  "conditionalclass",
+  "conditionalstyle",
+  "dataset",
+  "destroy",
+  "formfield",
+  "inbound",
+  "iswidget",
+  "onRender",
+  "outbound",
+  "prefab",
+  "ref",
+  "showindevice",
+  "styles",
+  "onLeftPanelAnimationChange"
+]);
+const SAFE_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "accessKey",
+  "autoCapitalize",
+  "autoComplete",
+  "autoCorrect",
+  "autoFocus",
+  "capture",
+  "cellPadding",
+  "cellSpacing",
+  "charSet",
+  "className",
+  "cols",
+  "colSpan",
+  "content",
+  "contentEditable",
+  "controls",
+  "coords",
+  "crossOrigin",
+  "dateTime",
+  "default",
+  "defaultChecked",
+  "defaultValue",
+  "dir",
+  "disabled",
+  "download",
+  "draggable",
+  "encType",
+  "form",
+  "height",
+  "hidden",
+  "hint",
+  "href",
+  "hrefLang",
+  "htmlFor",
+  "id",
+  "inputMode",
+  "label",
+  "lang",
+  "list",
+  "max",
+  "maxLength",
+  "media",
+  "method",
+  "min",
+  "minLength",
+  "multiple",
+  "name",
+  "noValidate",
+  "pattern",
+  "placeholder",
+  "readOnly",
+  "rel",
+  "required",
+  "role",
+  "rows",
+  "rowSpan",
+  "selected",
+  "slot",
+  "spellCheck",
+  "src",
+  "step",
+  "style",
+  "tabIndex",
+  "target",
+  "title",
+  "translate",
+  "type",
+  "value",
+  "width"
+]);
+const VALID_DOM_EVENT_HANDLERS = /* @__PURE__ */ new Set([
+  "onAbort",
+  "onAnimationEnd",
+  "onAnimationIteration",
+  "onAnimationStart",
+  "onAuxClick",
+  "onBeforeInput",
+  "onBlur",
+  "onCanPlay",
+  "onCanPlayThrough",
+  "onChange",
+  "onClick",
+  "onCompositionEnd",
+  "onCompositionStart",
+  "onCompositionUpdate",
+  "onContextMenu",
+  "onCopy",
+  "onCut",
+  "onDoubleClick",
+  "onDrag",
+  "onDragEnd",
+  "onDragEnter",
+  "onDragExit",
+  "onDragLeave",
+  "onDragOver",
+  "onDragStart",
+  "onDrop",
+  "onDurationChange",
+  "onEmptied",
+  "onEncrypted",
+  "onEnded",
+  "onError",
+  "onFocus",
+  "onGotPointerCapture",
+  "onInput",
+  "onInvalid",
+  "onKeyDown",
+  "onKeyPress",
+  "onKeyUp",
+  "onLoad",
+  "onLoadedData",
+  "onLoadedMetadata",
+  "onLoadStart",
+  "onLostPointerCapture",
+  "onMouseDown",
+  "onMouseEnter",
+  "onMouseLeave",
+  "onMouseMove",
+  "onMouseOut",
+  "onMouseOver",
+  "onMouseUp",
+  "onPaste",
+  "onPause",
+  "onPlay",
+  "onPlaying",
+  "onPointerCancel",
+  "onPointerDown",
+  "onPointerEnter",
+  "onPointerLeave",
+  "onPointerMove",
+  "onPointerOut",
+  "onPointerOver",
+  "onPointerUp",
+  "onProgress",
+  "onRateChange",
+  "onReset",
+  "onScroll",
+  "onSeeked",
+  "onSeeking",
+  "onSelect",
+  "onStalled",
+  "onSubmit",
+  "onSuspend",
+  "onTimeUpdate",
+  "onTouchCancel",
+  "onTouchEnd",
+  "onTouchMove",
+  "onTouchStart",
+  "onTransitionEnd",
+  "onVolumeChange",
+  "onWaiting",
+  "onWheel"
+]);
+const LOWERCASE_TO_REACT_ATTR = {
+  autocomplete: "autoComplete",
+  autocapitalize: "autoCapitalize",
+  autocorrect: "autoCorrect",
+  autofocus: "autoFocus",
+  accesskey: "accessKey",
+  classname: "className",
+  colspan: "colSpan",
+  contenteditable: "contentEditable",
+  crossorigin: "crossOrigin",
+  datetime: "dateTime",
+  defaultchecked: "defaultChecked",
+  defaultvalue: "defaultValue",
+  enctype: "encType",
+  hreflang: "hrefLang",
+  htmlfor: "htmlFor",
+  inputmode: "inputMode",
+  maxlength: "maxLength",
+  minlength: "minLength",
+  novalidate: "noValidate",
+  readonly: "readOnly",
+  rowspan: "rowSpan",
+  spellcheck: "spellCheck",
+  tabindex: "tabIndex"
+};
+const isLowercaseAttribute = (key) => key === key.toLowerCase();
+const isSafeAttributeName = (key) => SAFE_ATTRIBUTES.has(key) || key.startsWith("aria-") || key.startsWith("data-") || isLowercaseAttribute(key) || VALID_DOM_EVENT_HANDLERS.has(key);
+const isObjectLikeString = (value) => {
+  const trimmed = value.trim();
+  if (/^\[object\s*,?\s*object\]$/i.test(trimmed)) {
+    return true;
+  }
+  if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      return typeof parsed === "object" && parsed !== null;
+    } catch (e) {
+      return false;
+    }
+  }
+  return false;
+};
+const shouldStringifyBooleanAttribute = (key, value) => typeof value === "boolean" && isLowercaseAttribute(key) && !SAFE_ATTRIBUTES.has(key) && !key.startsWith("aria-") && !key.startsWith("data-");
+const removeInvalidAttributes = (attributes, explicitRemoveAttributes) => {
+  const filteredAttributes = {};
+  Object.keys(attributes).forEach((key) => {
+    var _a;
+    const value = attributes[key];
+    if ((explicitRemoveAttributes == null ? void 0 : explicitRemoveAttributes.includes(key)) || INTERNAL_ATTRIBUTES.has(key) || !isSafeAttributeName(key)) {
+      if (key === "ref") {
+        filteredAttributes[key] = value;
+      }
+      return;
+    }
+    if (Array.isArray(value) || typeof value === "object" && value !== null) {
+      return;
+    }
+    if (typeof value === "function" && !VALID_DOM_EVENT_HANDLERS.has(key)) {
+      return;
+    }
+    if (typeof value === "string" && value.trim() === "") {
+      return;
+    }
+    if (typeof value === "string" && isObjectLikeString(value)) {
+      return;
+    }
+    const normalizedKey = (_a = LOWERCASE_TO_REACT_ATTR[key]) != null ? _a : key;
+    filteredAttributes[normalizedKey] = shouldStringifyBooleanAttribute(normalizedKey, value) ? value.toString() : value;
+  });
+  return filteredAttributes;
+};
+export {
+  removeInvalidAttributes
+};

package/utils/custom-expression/index.d.ts

@@ -0,0 +1,43 @@
+import { transformMarkup } from "@wavemaker-ai/react-codegen/transpiler";
+import type { CustomExpressionComponent, TransformedMarkupInput } from "./parser";
+import { parseCustomExpressionToJsx } from "./parser";
+export type { CustomExpressionComponent, TransformedMarkupInput } from "./parser";
+export { parseCustomExpressionToJsx } from "./parser";
+/** Re-export for callers that need the same WaveMaker transpiler the table uses. */
+export { transformMarkup };
+/** Column-like objects that expose WaveMaker `customExpression` markup per field key. */
+export type CustomExpressionColumnSource = Record<string, {
+    customExpression?: string | undefined;
+}>;
+/**
+ * WaveMaker transpiler often emits `(row) => …`. Normalize arrow params so the row cell
+ * binding stays consistent with compiled JSX.
+ */
+export declare function normalizeTransformedMarkupRowBinding(transformedMarkup: TransformedMarkupInput): TransformedMarkupInput;
+/**
+ * Pass column custom-expression markup and get a row renderer for `customColumns` /
+ * `customExpressionColumns` state. Uses codegen `transformMarkup` unless overridden.
+ */
+export declare function compileCustomExpressionMarkup(markup: string, options: {
+    listener: unknown;
+    transformMarkup?: (markup: string) => TransformedMarkupInput;
+    parse?: typeof parseCustomExpressionToJsx;
+}): Promise<CustomExpressionComponent>;
+/**
+ * Stable fingerprint of all custom markup strings (sorted keys) — use for memo deps / merge dedupe.
+ */
+export declare function buildCustomExpressionSignature(columnSource: CustomExpressionColumnSource): string;
+export type BuildCustomExpressionComponentsMapOptions = {
+    columnSource: CustomExpressionColumnSource;
+    /** Listener / fragment passed through to the parser (e.g. Studio listener). */
+    listener: unknown;
+    /** Defaults to `@wavemaker-ai/react-codegen/transpiler` `transformMarkup`. */
+    transformMarkup?: (markup: string) => TransformedMarkupInput;
+    /** Override for tests or alternate parsers. */
+    parseCustomExpressionToJsx?: typeof parseCustomExpressionToJsx;
+};
+/**
+ * Parses every column on `columnSource` that defines `customExpression` into render callables.
+ * Store the result in table `customColumns` (or any map of column id → row renderer).
+ */
+export declare function buildCustomExpressionComponentsMap(options: BuildCustomExpressionComponentsMapOptions): Promise<Record<string, CustomExpressionComponent>>;

package/utils/custom-expression/index.js

@@ -0,0 +1,68 @@
+import { transformMarkup } from "@wavemaker-ai/react-codegen/transpiler";
+import { parseCustomExpressionToJsx } from "./parser";
+import { parseCustomExpressionToJsx as parseCustomExpressionToJsx2 } from "./parser";
+function normalizeTransformedMarkupRowBinding(transformedMarkup) {
+  transformedMarkup.markup = transformedMarkup.markup.replace(
+    /\(([^)]*)\)\s*=>/g,
+    (_match, params) => {
+      const cleaned = params.split(",").map((p) => p.trim()).filter((p) => p !== "row").join(", ");
+      return `(${cleaned}) =>`;
+    }
+  );
+  return transformedMarkup;
+}
+async function compileCustomExpressionMarkup(markup, options) {
+  var _a, _b;
+  const parse = (_a = options.parse) != null ? _a : parseCustomExpressionToJsx;
+  const tm = (_b = options.transformMarkup) != null ? _b : transformMarkup;
+  const transformedMarkup = normalizeTransformedMarkupRowBinding(tm(markup));
+  return parse(transformedMarkup, options.listener);
+}
+function buildCustomExpressionSignature(columnSource) {
+  try {
+    return Object.keys(columnSource).filter((key) => {
+      var _a;
+      return (_a = columnSource[key]) == null ? void 0 : _a.customExpression;
+    }).map((key) => `${key}\0${String(columnSource[key].customExpression)}`).sort().join("");
+  } catch (e) {
+    return "";
+  }
+}
+async function buildCustomExpressionComponentsMap(options) {
+  const {
+    columnSource,
+    transformMarkup: transformMarkupOpt,
+    listener,
+    parseCustomExpressionToJsx: parseFn = parseCustomExpressionToJsx
+  } = options;
+  const tm = transformMarkupOpt != null ? transformMarkupOpt : transformMarkup;
+  const keys = Object.keys(columnSource).filter((key) => columnSource[key].customExpression);
+  if (keys.length === 0) {
+    return {};
+  }
+  const results = await Promise.all(
+    keys.map(async (key) => {
+      const transformedMarkup = normalizeTransformedMarkupRowBinding(
+        tm(columnSource[key].customExpression, {
+          appUrl: "",
+          insideTableColumn: true
+        })
+      );
+      const component = await parseFn(transformedMarkup, listener);
+      return { key, component };
+    })
+  );
+  const out = {};
+  for (const { key, component } of results) {
+    out[key] = component;
+  }
+  return out;
+}
+export {
+  buildCustomExpressionComponentsMap,
+  buildCustomExpressionSignature,
+  compileCustomExpressionMarkup,
+  normalizeTransformedMarkupRowBinding,
+  parseCustomExpressionToJsx2 as parseCustomExpressionToJsx,
+  transformMarkup
+};