@wix/editor-react-components 1.2153.0

package/dist/site/components/chunks/corvidEvents.js

@@ -0,0 +1,666 @@
+import { r as reportError, a as reportWarning } from "./reporters.js";
+import { a as isNumber, b as isIn, c as isBelow, d as isAbove, e as isInteger, f as isString, g as isBoolean, h as isDate, i as isNil, j as isFunction, k as isArray, l as isObject } from "./assert.js";
+import { i as invalidEnumValueMessage, a as invalidNumberBoundsMessage, b as invalidStringLengthMessage, p as patternMismatchMessage, m as missingFieldMessage, u as unknownFieldMessage, n as nilAssignmentMessage, c as invalidTypeMessage } from "./messages.js";
+function validateNumber(value, schema, reportError2, messageParams) {
+  const { minimum, maximum, enum: enumArray } = schema;
+  if (!isNumber(value)) {
+    return ValidationResult.InvalidType;
+  }
+  if (enumArray && !isIn(value, enumArray)) {
+    reportError2(
+      invalidEnumValueMessage({
+        value,
+        enum: enumArray,
+        ...messageParams
+      }),
+      { ...messageParams, value }
+    );
+    return ValidationResult.Invalid;
+  }
+  if (isNumber(minimum) && isBelow(value, minimum) || isNumber(maximum) && isAbove(value, maximum)) {
+    reportError2(
+      invalidNumberBoundsMessage({
+        value,
+        minimum,
+        // either minimum or maximum are numbers here
+        maximum,
+        ...messageParams
+      }),
+      { ...messageParams, value }
+    );
+    return ValidationResult.Invalid;
+  }
+  return ValidationResult.Valid;
+}
+function validateInteger(value, schema, reportError2, messageParams) {
+  const { minimum, maximum, enum: enumArray } = schema;
+  if (!isInteger(value)) {
+    return ValidationResult.InvalidType;
+  }
+  if (enumArray && !isIn(value, enumArray)) {
+    reportError2(
+      invalidEnumValueMessage({
+        value,
+        enum: enumArray,
+        ...messageParams
+      }),
+      { ...messageParams, value }
+    );
+    return ValidationResult.Invalid;
+  }
+  if (isNumber(minimum) && isBelow(value, minimum) || isNumber(maximum) && isAbove(value, maximum)) {
+    reportError2(
+      invalidNumberBoundsMessage({
+        value,
+        minimum,
+        // minimum / maximum has to be of number type
+        maximum,
+        ...messageParams
+      }),
+      { ...messageParams, value }
+    );
+    return ValidationResult.Invalid;
+  }
+  return ValidationResult.Valid;
+}
+function validateString(value, schema, reportError2, messageParams) {
+  const { minLength, maxLength, enum: enumArray, pattern } = schema;
+  if (!isString(value)) {
+    return ValidationResult.InvalidType;
+  }
+  if (enumArray && !isIn(value, enumArray)) {
+    reportError2(
+      invalidEnumValueMessage({
+        value,
+        enum: enumArray,
+        ...messageParams
+      }),
+      { ...messageParams, value }
+    );
+    return ValidationResult.Invalid;
+  }
+  if (minLength && isBelow(value.length, minLength) || maxLength && isAbove(value.length, maxLength)) {
+    reportError2(
+      invalidStringLengthMessage({
+        value,
+        minimum: minLength,
+        // minimum / maximum has to be of type number,
+        maximum: maxLength,
+        ...messageParams
+      }),
+      { ...messageParams, value }
+    );
+    return ValidationResult.Invalid;
+  }
+  if (pattern && !new RegExp(pattern).test(value)) {
+    reportError2(
+      patternMismatchMessage({
+        value,
+        ...messageParams
+      }),
+      { ...messageParams, value }
+    );
+    return ValidationResult.Invalid;
+  }
+  return ValidationResult.Valid;
+}
+function validateBoolean(value) {
+  if (!isBoolean(value)) {
+    return ValidationResult.InvalidType;
+  }
+  return ValidationResult.Valid;
+}
+function validateDate(value) {
+  if (!isDate(value)) {
+    return ValidationResult.InvalidType;
+  }
+  return ValidationResult.Valid;
+}
+function validateNil(value) {
+  if (!isNil(value)) {
+    return ValidationResult.InvalidType;
+  }
+  return ValidationResult.Valid;
+}
+function validateFunction(value) {
+  if (!isFunction(value)) {
+    return ValidationResult.InvalidType;
+  }
+  return ValidationResult.Valid;
+}
+function isTupleSchema(schema) {
+  return Array.isArray(schema);
+}
+function validateArray(value, schema, validateSchema, reportError2, messageParams, suppressIndexError = false) {
+  if (!isArray(value)) {
+    return ValidationResult.InvalidType;
+  }
+  let isValid = ValidationResult.Valid;
+  if (schema.items) {
+    const itemsToValidateCount = isTupleSchema(schema.items) ? Math.min(value.length, schema.items.length) : value.length;
+    for (let itemIndex = 0; itemIndex < itemsToValidateCount; itemIndex++) {
+      const item = value[itemIndex];
+      let itemSchema;
+      let propName;
+      if (isTupleSchema(schema.items)) {
+        itemSchema = schema.items[itemIndex];
+        propName = schema.items[itemIndex].name;
+      } else {
+        itemSchema = schema.items;
+        propName = schema.name;
+      }
+      const isItemValid = validateSchema(item, itemSchema, {
+        functionName: messageParams.functionName,
+        propertyName: propName || messageParams.propertyName,
+        index: !suppressIndexError ? itemIndex : void 0
+      });
+      if (!isItemValid) {
+        isValid = ValidationResult.Invalid;
+      }
+    }
+  }
+  return isValid;
+}
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const getOwnPropertyNames = Object.getOwnPropertyNames;
+const noop = () => {
+};
+function validateObject(value, schema, validateSchema, reportError2, reportWarning2, messageParams) {
+  if (!isObject(value)) {
+    return ValidationResult.InvalidType;
+  }
+  if (schema.oneOf) {
+    return schema.oneOf.map(
+      (variant) => validateObject(
+        value,
+        variant,
+        validateSchema,
+        noop,
+        reportWarning2,
+        messageParams
+      )
+    ).filter((validity) => validity === ValidationResult.Valid).length === 1 ? ValidationResult.Valid : ValidationResult.Invalid;
+  }
+  if (schema.required) {
+    for (let propNameIdx = 0; propNameIdx < schema.required.length; propNameIdx++) {
+      if (!hasOwnProperty.call(value, schema.required[propNameIdx])) {
+        reportError2(
+          missingFieldMessage({
+            functionName: messageParams.functionName,
+            index: messageParams.index,
+            propertyName: schema.required[propNameIdx]
+          }),
+          { ...messageParams, value }
+        );
+        return ValidationResult.Invalid;
+      }
+    }
+  }
+  const propNames = getOwnPropertyNames(schema.properties ?? {});
+  if (schema.additionalProperties === false) {
+    const invalidPropertyNames = getOwnPropertyNames(value).filter(
+      (key) => !propNames.includes(key)
+    );
+    if (invalidPropertyNames.length) {
+      const message = unknownFieldMessage({
+        functionName: messageParams.functionName,
+        index: messageParams.index,
+        propertyNames: invalidPropertyNames
+      });
+      reportError2(message);
+      return ValidationResult.Invalid;
+    }
+  }
+  for (let propNameIdx = 0; propNameIdx < propNames.length; propNameIdx++) {
+    const propName = propNames[propNameIdx];
+    if (hasOwnProperty.call(value, propName)) {
+      const propSchema = schema.properties[propName];
+      const propValue = value[propName];
+      if (!validateSchema(propValue, propSchema, {
+        functionName: messageParams.functionName,
+        index: messageParams.index,
+        propertyName: propName
+      })) {
+        return ValidationResult.Invalid;
+      }
+    }
+  }
+  return ValidationResult.Valid;
+}
+const ValidationResult = {
+  Valid: "valid",
+  Invalid: "invalid",
+  InvalidType: "invalid-type"
+};
+function createSchemaValidator({ reportError: reportError2, reportWarning: reportWarning2 }, compName, { suppressIndexErrors = false } = {}) {
+  function validate(value, schema, setterName) {
+    return validateSchema(value, schema, {
+      functionName: setterName,
+      propertyName: setterName,
+      /**
+       * This intentional? In such a case all errors related to "index"
+       * will never be fired
+       */
+      index: void 0
+    });
+  }
+  function validateSchema(value, schema, params) {
+    if (schema.warnIfNil && isNil(value)) {
+      reportWarning2(
+        nilAssignmentMessage({
+          ...params,
+          compName
+        }),
+        { ...params, value }
+      );
+    }
+    let typeIdx = 0;
+    for (; typeIdx < schema.type.length; typeIdx++) {
+      const validateSchemaForType = validatorsMap[schema.type[typeIdx]];
+      const validationResult = validateSchemaForType(
+        value,
+        schema,
+        params
+      );
+      if (validationResult !== ValidationResult.InvalidType) {
+        return validationResult === ValidationResult.Valid;
+      }
+    }
+    if (typeIdx === schema.type.length) {
+      reportError2(
+        invalidTypeMessage({
+          value,
+          types: schema.type,
+          ...params
+        }),
+        { ...params, value }
+      );
+    }
+    return false;
+  }
+  const validatorsMap = {
+    object: (value, schema, messageParams) => {
+      return validateObject(
+        value,
+        schema,
+        validateSchema,
+        reportError2,
+        reportWarning2,
+        messageParams
+      );
+    },
+    array: (value, schema, messageParams) => {
+      return validateArray(
+        value,
+        schema,
+        validateSchema,
+        reportError2,
+        messageParams,
+        suppressIndexErrors
+      );
+    },
+    number: (value, schema, messageParams) => {
+      return validateNumber(
+        value,
+        schema,
+        reportError2,
+        messageParams
+      );
+    },
+    integer: (value, schema, messageParams) => {
+      return validateInteger(
+        value,
+        schema,
+        reportError2,
+        messageParams
+      );
+    },
+    string: (value, schema, messageParams) => {
+      return validateString(
+        value,
+        schema,
+        reportError2,
+        messageParams
+      );
+    },
+    boolean: (value) => {
+      return validateBoolean(value);
+    },
+    date: (value) => {
+      return validateDate(value);
+    },
+    nil: (value) => {
+      return validateNil(value);
+    },
+    function: (value) => {
+      return validateFunction(value);
+    }
+  };
+  return validate;
+}
+function createCompSchemaValidator(compName, { suppressIndexErrors = false } = {}) {
+  return createSchemaValidator({ reportError, reportWarning }, compName, {
+    suppressIndexErrors
+  });
+}
+function withValidation(sdkFactory, schema, rules = {}) {
+  return (api) => {
+    const sdk = sdkFactory(api);
+    const schemaValidator = createCompSchemaValidator(api.metaData.role);
+    const argsSchemaValidator = createCompSchemaValidator(api.metaData.role, {
+      suppressIndexErrors: true
+    });
+    const sdkWithValidation = Object.keys(sdk).reduce((acc, sdkPropName) => {
+      const propDesc = Object.getOwnPropertyDescriptor(
+        sdk,
+        sdkPropName
+      );
+      const propWithValidationDesc = {
+        // retrieve value from sdk
+        enumerable: true,
+        configurable: true
+      };
+      if (propDesc.value) {
+        if (typeof propDesc.value === "function") {
+          propWithValidationDesc.value = (...args) => {
+            const argsSchema = schema.properties[sdkPropName] && schema.properties[sdkPropName].args;
+            const customValidation = rules[sdkPropName];
+            let isValid = true;
+            if (argsSchema) {
+              isValid = argsSchemaValidator(
+                args,
+                { type: ["array"], items: argsSchema },
+                sdkPropName
+              );
+            }
+            if (isValid && customValidation) {
+              isValid = customValidation.every((p) => p(args, api));
+            }
+            return isValid ? propDesc.value(...args) : void 0;
+          };
+        } else {
+          propWithValidationDesc.value = propDesc.value;
+        }
+      } else {
+        if (propDesc.get) {
+          propWithValidationDesc.get = () => sdk[sdkPropName];
+        }
+        if (propDesc.set) {
+          propWithValidationDesc.set = (value) => {
+            const customValidation = rules[sdkPropName];
+            let isValid = true;
+            if (schema.properties[sdkPropName]) {
+              isValid = schemaValidator(
+                value,
+                schema.properties[sdkPropName],
+                sdkPropName
+              );
+            }
+            if (isValid && customValidation) {
+              isValid = customValidation.every((p) => p(value, api));
+            }
+            if (!isValid) {
+              return;
+            }
+            sdk[sdkPropName] = value;
+          };
+        }
+      }
+      Object.defineProperty(acc, sdkPropName, propWithValidationDesc);
+      return acc;
+    }, {});
+    return sdkWithValidation;
+  };
+}
+const ACTION_TYPES = {
+  CLICK: "click",
+  DBL_CLICK: "dblClick",
+  MOUSE_IN: "mouseenter",
+  MOUSE_OUT: "mouseleave",
+  CHANGE: "change",
+  BLUR: "blur",
+  FOCUS: "focus",
+  IMAGE_CHANGED: "imageChanged",
+  IMAGE_EXPANDED: "imageExpanded",
+  ON_INPUT: "onInput",
+  ITEM_CLICKED: "itemClicked",
+  CELL_SELECT: "cellSelect",
+  CELL_EDIT: "cellEdit",
+  ROW_SELECT: "rowSelect",
+  FETCH_DATA: "fetchData",
+  DATA_CHANGE: "dataChange",
+  ON_TIMEOUT: "onTimeout",
+  ON_VERIFY: "onVerified",
+  ON_ERROR: "onError",
+  ON_PLAY: "onPlay",
+  ON_PAUSE: "onPause",
+  ON_PROGRESS: "onProgress",
+  ON_ENDED: "onEnded",
+  AUTOPLAY_OFF: "autoplayOff",
+  AUTOPLAY_ON: "autoplayOn",
+  PLAY_ENDED: "playEnded",
+  PLAY_PROGRESS: "playProgress",
+  KEY_PRESS: "keyPress",
+  KEY_UP: "keyUp",
+  KEY_DOWN: "keyDown",
+  SCREEN_IN: "screenIn",
+  VIEWPORT_ENTER: "viewportEnter",
+  VIEWPORT_LEAVE: "viewportLeave",
+  SCROLL: "scroll",
+  VALIDATE: "validate",
+  SET_CUSTOM_VALIDITY: "setCustomValidity",
+  SYNC_VALIDATION_DATA: "syncValidationData",
+  UPDATE_VALIDITY_INDICATION: "updateValidityIndication",
+  MESSAGE: "message",
+  UPLOAD_COMPLETE: "uploadComplete",
+  ITEM_READY: "itemReady",
+  ITEM_REMOVED: "itemRemoved",
+  TAG_CLICK: "tagClick",
+  QUICK_ACTION_BAR_ITEM_CLICKED: "quickActionBarItemClicked",
+  GOOGLE_MAP_MARKER_CLICKED: "markerClicked",
+  GOOGLE_MAP_CLICKED: "mapClicked",
+  ICON_MOUSE_IN: "iconMouseIn",
+  ON_STATE_CHANGE: "onStateChange",
+  ITEM_MOUSE_IN: "itemMouseIn",
+  ITEM_MOUSE_OUT: "itemMouseOut",
+  ITEM_MOUSE_CLICK: "itemMouseClick",
+  ITEM_MOUSE_DOUBLE_CLICK: "itemMouseDblClick",
+  ON_COLOR_CHANGE: "onColorChange",
+  ON_FONT_CHANGE: "onFontChange",
+  ON_OPACITY_CHANGE: "onOpacityChange"
+};
+const EVENT_TYPES_MAP = {
+  [ACTION_TYPES.CLICK]: "onClick",
+  [ACTION_TYPES.DBL_CLICK]: "onDblClick",
+  [ACTION_TYPES.MOUSE_IN]: "onMouseIn",
+  [ACTION_TYPES.MOUSE_OUT]: "onMouseOut",
+  [ACTION_TYPES.CHANGE]: "onChange",
+  [ACTION_TYPES.ON_INPUT]: "onInput",
+  [ACTION_TYPES.BLUR]: "onBlur",
+  [ACTION_TYPES.FOCUS]: "onFocus",
+  [ACTION_TYPES.IMAGE_CHANGED]: "onCurrentItemChanged",
+  [ACTION_TYPES.IMAGE_EXPANDED]: void 0,
+  [ACTION_TYPES.ITEM_CLICKED]: "onItemClicked",
+  [ACTION_TYPES.CELL_SELECT]: "onCellSelect",
+  [ACTION_TYPES.CELL_EDIT]: void 0,
+  [ACTION_TYPES.ROW_SELECT]: "onRowSelect",
+  [ACTION_TYPES.FETCH_DATA]: void 0,
+  [ACTION_TYPES.DATA_CHANGE]: "onDataChange",
+  [ACTION_TYPES.ON_TIMEOUT]: "onTimeout",
+  [ACTION_TYPES.ON_VERIFY]: "onVerified",
+  [ACTION_TYPES.ON_ERROR]: "onError",
+  [ACTION_TYPES.ON_PLAY]: "onPlay",
+  [ACTION_TYPES.ON_PAUSE]: "onPause",
+  [ACTION_TYPES.ON_PROGRESS]: "onProgress",
+  [ACTION_TYPES.ON_ENDED]: "onEnded",
+  [ACTION_TYPES.AUTOPLAY_OFF]: "onPause",
+  [ACTION_TYPES.AUTOPLAY_ON]: "onPlay",
+  [ACTION_TYPES.PLAY_ENDED]: void 0,
+  [ACTION_TYPES.PLAY_PROGRESS]: void 0,
+  [ACTION_TYPES.KEY_PRESS]: "onKeyPress",
+  [ACTION_TYPES.KEY_UP]: "onKeyUp",
+  [ACTION_TYPES.KEY_DOWN]: "onKeyDown",
+  [ACTION_TYPES.SCREEN_IN]: void 0,
+  [ACTION_TYPES.VIEWPORT_ENTER]: "onViewportEnter",
+  [ACTION_TYPES.VIEWPORT_LEAVE]: "onViewportLeave",
+  [ACTION_TYPES.SCROLL]: void 0,
+  [ACTION_TYPES.VALIDATE]: void 0,
+  [ACTION_TYPES.SET_CUSTOM_VALIDITY]: void 0,
+  [ACTION_TYPES.SYNC_VALIDATION_DATA]: void 0,
+  [ACTION_TYPES.UPDATE_VALIDITY_INDICATION]: void 0,
+  [ACTION_TYPES.MESSAGE]: "onMessage",
+  [ACTION_TYPES.UPLOAD_COMPLETE]: void 0,
+  [ACTION_TYPES.ITEM_READY]: "onItemReady",
+  [ACTION_TYPES.ITEM_REMOVED]: "onItemRemoved",
+  [ACTION_TYPES.TAG_CLICK]: void 0,
+  [ACTION_TYPES.QUICK_ACTION_BAR_ITEM_CLICKED]: "onItemClicked",
+  [ACTION_TYPES.GOOGLE_MAP_MARKER_CLICKED]: "onMarkerClicked",
+  [ACTION_TYPES.GOOGLE_MAP_CLICKED]: "onMapClicked",
+  [ACTION_TYPES.ICON_MOUSE_IN]: void 0,
+  [ACTION_TYPES.ON_STATE_CHANGE]: "onStateChange",
+  [ACTION_TYPES.ITEM_MOUSE_IN]: "onItemMouseIn",
+  [ACTION_TYPES.ITEM_MOUSE_OUT]: "onItemMouseOut",
+  [ACTION_TYPES.ITEM_MOUSE_CLICK]: "onItemClick",
+  [ACTION_TYPES.ITEM_MOUSE_DOUBLE_CLICK]: "onItemDblClick",
+  [ACTION_TYPES.ON_COLOR_CHANGE]: "onColorChange",
+  [ACTION_TYPES.ON_FONT_CHANGE]: "onFontChange",
+  [ACTION_TYPES.ON_OPACITY_CHANGE]: "onOpacityChange"
+};
+const reactToCorvidEventType = {
+  dblclick: "dblClick",
+  keydown: "keyPress",
+  input: "onInput"
+};
+const convertToCorvidEventBase = (event) => {
+  const { target, type, context } = event;
+  return { target, type: reactToCorvidEventType[type] ?? type, context };
+};
+const convertToCorvidMouseEvent = (event) => {
+  const { clientX, clientY, pageX, pageY, screenX, screenY, nativeEvent } = event;
+  const { offsetX, offsetY } = nativeEvent;
+  return {
+    clientX,
+    clientY,
+    pageX,
+    pageY,
+    screenX,
+    screenY,
+    offsetX,
+    offsetY
+  };
+};
+const convertToCorvidKeyboardEvent = (event) => {
+  const { altKey, ctrlKey, key, metaKey, shiftKey } = event;
+  return {
+    key,
+    altKey,
+    ctrlKey,
+    metaKey,
+    shiftKey
+  };
+};
+const functionValidator = (value, eventName, role) => {
+  return createCompSchemaValidator(role)(
+    value,
+    {
+      type: ["function"]
+    },
+    eventName
+  );
+};
+const eventNameMapToMethodName = {
+  onMouseEnter: "onMouseIn",
+  onMouseLeave: "onMouseOut"
+};
+const removeOnPrefix = (st) => st.replace(/^on/i, "");
+const mapMethodNameToEventName = (methodName) => {
+  const mapEntry = Object.entries(eventNameMapToMethodName).find(
+    ([_, value]) => removeOnPrefix(value.toLowerCase()) === removeOnPrefix(methodName.toLowerCase())
+  );
+  return (mapEntry == null ? void 0 : mapEntry[0]) ?? methodName;
+};
+const createEventListenerState = (api) => {
+  return api.createSdkState(
+    { listeners: [] },
+    "eventListeners"
+  );
+};
+const registerCorvidEvent = (eventName, api, cb, projection) => {
+  const { create$w, createEvent, registerEvent, getSdkInstance, metaData } = api;
+  const setterName = eventNameMapToMethodName[eventName] ?? eventName;
+  if (!functionValidator(cb, setterName, metaData.role)) {
+    return getSdkInstance();
+  }
+  const [eventListenerState, setEventListenerState] = createEventListenerState(api);
+  const unregisterEvent = registerEvent(
+    eventName,
+    /**
+     * `eventPayload` adds extra data into native React events
+     * which will be sanitized by the platform
+     */
+    (event, eventPayload) => {
+      const baseEvent = createEvent({ type: event.type, compId: event.compId });
+      const $w = create$w({ context: baseEvent.context });
+      const projectionEvent = projection == null ? void 0 : projection({
+        componentEvent: event,
+        eventPayload
+      });
+      cb(
+        {
+          ...convertToCorvidEventBase(baseEvent),
+          ...projectionEvent
+        },
+        $w
+      );
+    }
+  );
+  const listener = {
+    eventName,
+    compId: metaData.compId,
+    cb,
+    unregister: unregisterEvent
+  };
+  setEventListenerState({
+    listeners: [...eventListenerState.listeners, listener]
+  });
+  return getSdkInstance();
+};
+const isEventNameMatches = (eventName, userRequestedEventNameOrActionType) => {
+  const targetEventName = mapMethodNameToEventName(
+    EVENT_TYPES_MAP[userRequestedEventNameOrActionType] ?? userRequestedEventNameOrActionType
+  );
+  return eventName.toLowerCase() === targetEventName.toLowerCase();
+};
+const unregisterCorvidEvent = (eventNameOrActionType, api, cb) => {
+  const { metaData, getSdkInstance } = api;
+  const [eventListenerState, setEventListenerState] = createEventListenerState(api);
+  const eventListeners = eventListenerState.listeners.filter(
+    (listener) => isEventNameMatches(listener.eventName, eventNameOrActionType) && listener.cb === cb && listener.compId === metaData.compId
+  );
+  for (const listener of eventListeners) {
+    listener.unregister();
+  }
+  setEventListenerState({
+    listeners: eventListenerState.listeners.filter(
+      (listener) => !eventListeners.includes(listener)
+    )
+  });
+  return getSdkInstance();
+};
+const registerCorvidKeyboardEvent = (eventName, api, cb, payloadProjection) => registerCorvidEvent(eventName, api, cb, ({ componentEvent, eventPayload }) => ({
+  ...convertToCorvidKeyboardEvent(componentEvent),
+  ...eventPayload && (payloadProjection == null ? void 0 : payloadProjection(eventPayload))
+}));
+const registerCorvidMouseEvent = (eventName, api, cb, payloadProjection) => registerCorvidEvent(eventName, api, cb, ({ componentEvent, eventPayload }) => ({
+  ...convertToCorvidMouseEvent(componentEvent),
+  ...eventPayload && (payloadProjection == null ? void 0 : payloadProjection(eventPayload))
+}));
+export {
+  createSchemaValidator as a,
+  registerCorvidMouseEvent as b,
+  createCompSchemaValidator as c,
+  registerCorvidKeyboardEvent as d,
+  registerCorvidEvent as r,
+  unregisterCorvidEvent as u,
+  withValidation as w
+};