react-luna-form 0.0.40 → 0.0.42

package/dist/timezone/esm/chunk-JRS2SJNX.js

@@ -0,0 +1,818 @@
+// ../luna-core/src/util/is-type.ts
+function isObject(value) {
+  return value !== null && Object.prototype.toString.call(value) === "[object Object]";
+}
+function isEmpty(value) {
+  return value === null || value === void 0 || value === "";
+}
+function isValue(value) {
+  return isString(value) || typeof value === "number" || isBoolean(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isDataSource(value) {
+  return isObject(value) && "url" in value;
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+
+// ../luna-core/src/util/constant.ts
+var INPUT = "input";
+var INPUT_DATE = "input/date";
+var INPUT_EMAIL = "input/email";
+var INPUT_NUMBER = "input/number";
+var INPUT_TIME = "input/time";
+var TEXTAREA = "textarea";
+var RADIO = "radio";
+var CHECKBOX = "checkbox";
+var SELECT = "select";
+var SELECT_MONTH = "select/month";
+var SELECT_TIMEZONE = "select/timezone";
+var SELECT_YEAR = "select/year";
+var CHIPS = "chips";
+var DESCRIPTION = "description";
+var LABEL = "label";
+var VALUE = "value";
+var OPTIONS = "options";
+var TYPE_EMAIL = "email";
+var TYPE_NUMBER = "number";
+var TYPE_PASSWORD = "password";
+var TYPE_TEL = "tel";
+var TYPE_TEXT = "text";
+var MAX = "max";
+var MIN = "min";
+var SOURCE = "source";
+var STATE = "state";
+var COMMON_URL = "http://luna.internal";
+
+// ../luna-core/src/util/extract.ts
+function getEntity(selected, collection = [], entity = VALUE) {
+  if (Array.isArray(collection)) {
+    return collection.find((item) => {
+      const current = getCurrentValue(item, entity);
+      if (current !== void 0 && `${current}` === selected) {
+        return item;
+      }
+    }) ?? { value: selected };
+  }
+  return { value: selected };
+}
+function getCurrentValue(value, entity = VALUE) {
+  if (value != null) {
+    if (Array.isArray(value) && value.every(isValue)) {
+      return value;
+    }
+    if (isValue(value)) {
+      return value;
+    }
+    if (isObject(value)) {
+      const result = getValue(value, entity);
+      if (isValue(result)) {
+        return result;
+      }
+    }
+  }
+}
+function getValue(value, namespace) {
+  const result = extract(value, namespace);
+  if (isValue(result)) {
+    return result;
+  }
+}
+function extract(value, namespace) {
+  if (!namespace || !isObject(value)) {
+    return null;
+  }
+  const keys = namespace.split(".").filter((key) => key !== "");
+  if (keys.length === 0) {
+    return null;
+  }
+  let result = value;
+  for (const key of keys) {
+    if (isObject(result) && key in result) {
+      const obj = result;
+      result = obj[key];
+    } else {
+      return null;
+    }
+  }
+  return result;
+}
+function toOptions(data, options = {
+  description: DESCRIPTION,
+  label: LABEL,
+  value: VALUE
+}) {
+  return data.map((item) => {
+    if (isObject(item)) {
+      const label = extract(item, options.label);
+      const value = extract(item, options.value);
+      if (isValue(label) && isValue(value)) {
+        const description = extract(item, options.description);
+        return {
+          label: `${label}`,
+          value: `${value}`,
+          ...isValue(description) && { description: `${description}` }
+        };
+      }
+    }
+    return item;
+  });
+}
+
+// ../luna-core/src/util/is-input.ts
+var isSelectMonth = (field) => createTypeChecker(SELECT_MONTH)(field);
+var isSelectYear = (field) => createTypeChecker(SELECT_YEAR)(field);
+var isSelectTimezone = (field) => createTypeChecker(SELECT_TIMEZONE)(field);
+var isDate = createTypeChecker(INPUT_DATE);
+var isTime = createTypeChecker(INPUT_TIME);
+var isCheckbox = createTypeChecker(CHECKBOX);
+var isChips = createTypeChecker(CHIPS);
+var isRadio = createTypeChecker(RADIO);
+var isInput = createTypeChecker(INPUT);
+var isSelect = createTypeChecker(SELECT);
+var isTextArea = createTypeChecker(TEXTAREA);
+var isText = createTypeChecker(
+  TYPE_TEXT,
+  TYPE_EMAIL,
+  TYPE_PASSWORD,
+  TYPE_TEL
+);
+var isEmail = createTypeChecker(INPUT_EMAIL, TYPE_EMAIL);
+var isNumber = createTypeChecker(INPUT_NUMBER, TYPE_NUMBER);
+function isClickable(field) {
+  return isRadio(field) || isCheckbox(field);
+}
+function isOptions(field) {
+  return isSelect(field) || isRadio(field);
+}
+function isValidValue(value) {
+  return value !== void 0 && value !== null && value !== "";
+}
+function createTypeChecker(...types) {
+  return (field) => {
+    const inputType = isString(field.type) ? field.type : void 0;
+    if (!inputType) {
+      return false;
+    }
+    return types.some((type) => {
+      return inputType === type || inputType?.startsWith(`${type}/`);
+    });
+  };
+}
+
+// ../luna-core/src/util/timezone-compute.ts
+var cachedResult = null;
+function getCachedTimezones() {
+  return cachedResult;
+}
+function getUserTimezone() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+function getOffset(tz, date) {
+  const parts = new Intl.DateTimeFormat("en", {
+    timeZone: tz,
+    timeZoneName: "longOffset"
+  }).formatToParts(date);
+  const raw = parts.find((part) => part.type === "timeZoneName")?.value ?? "GMT+00:00";
+  return raw.replace("GMT", "UTC");
+}
+function getCity(tz) {
+  return tz.slice(tz.lastIndexOf("/") + 1).replace(/_/g, " ");
+}
+function computeTimezoneGroups(entries) {
+  if (cachedResult) {
+    return cachedResult;
+  }
+  const date = /* @__PURE__ */ new Date();
+  const detectedTimezone = getUserTimezone();
+  const groupMap = /* @__PURE__ */ new Map();
+  let detectedItem = null;
+  for (const entry of entries) {
+    const offset = getOffset(entry.value, date);
+    const item = {
+      value: entry.value,
+      label: `${entry.label} - (${offset})`
+    };
+    if (entry.value === detectedTimezone) {
+      detectedItem = item;
+      continue;
+    }
+    const existing = groupMap.get(entry.region);
+    if (existing) {
+      existing.push(item);
+    } else {
+      groupMap.set(entry.region, [item]);
+    }
+  }
+  if (!detectedItem) {
+    detectedItem = {
+      value: detectedTimezone,
+      label: `${getCity(detectedTimezone)} - (${getOffset(detectedTimezone, date)})`
+    };
+  }
+  for (const items of groupMap.values()) {
+    items.sort((a, b) => a.label.localeCompare(b.label));
+  }
+  const sortedGroups = Array.from(groupMap.entries()).sort(([a], [b]) => a.localeCompare(b)).map(([label, items]) => ({ label, items }));
+  cachedResult = [
+    { label: "Suggested", items: [detectedItem] },
+    ...sortedGroups
+  ];
+  return cachedResult;
+}
+
+// ../luna-core/src/util/string.ts
+var REGEX_MARKDOWN_LINK = /\[([^\]]{1,500})\]\(([^)]{1,2000})\)/g;
+function interpolate(template, values = {}) {
+  if (isString(template)) {
+    return replacePlaceholders(template, values);
+  }
+  if (Array.isArray(template)) {
+    return template.map((item) => {
+      return interpolate(item, values);
+    });
+  }
+  if (isObject(template)) {
+    const results = {};
+    for (const key in template) {
+      results[key] = interpolate(template[key], values);
+    }
+    return results;
+  }
+  return template;
+}
+function interpolateIfNeeded(template, values = {}) {
+  return isInterpolated(template) ? interpolate(template, values) : template;
+}
+function isInterpolated(template) {
+  if (isString(template)) {
+    return /{([^}]{1,200})}/.test(template);
+  }
+  if (Array.isArray(template)) {
+    return template.some((item) => isInterpolated(item));
+  }
+  if (isObject(template)) {
+    return Object.values(template).some((value) => isInterpolated(value));
+  }
+  return false;
+}
+function replacePlaceholders(template, values = {}) {
+  return template.replace(/{([^}]{1,200})}/g, (match, key) => {
+    const value = key.includes(".") ? extract(values, key) : values[key];
+    if (isValue(value)) {
+      return String(value);
+    }
+    return match;
+  });
+}
+function formatMarkdown(text, callback) {
+  if (!isString(text)) {
+    return null;
+  }
+  if (!text || text.trim().length === 0) {
+    return null;
+  }
+  let match;
+  let lastIndex = 0;
+  let hasMatch = false;
+  const parts = [];
+  while ((match = REGEX_MARKDOWN_LINK.exec(text)) !== null) {
+    const [fullMatch, linkText, url] = match;
+    const index = match.index;
+    hasMatch = true;
+    if (index > lastIndex) {
+      parts.push(text.substring(lastIndex, index));
+    }
+    const value = callback ? callback(index, url, linkText) : fullMatch;
+    parts.push(value);
+    lastIndex = index + fullMatch.length;
+  }
+  if (!hasMatch) {
+    return text;
+  }
+  if (lastIndex < text.length) {
+    parts.push(text.substring(lastIndex));
+  }
+  return parts;
+}
+
+// ../luna-core/src/handle/proxy-event.ts
+function handleProxyEvent(events = [], callback) {
+  const values = [];
+  const sources = [];
+  const states = [];
+  for (const event of events) {
+    if (event.action === VALUE) {
+      values.push(event);
+    }
+    if (event.action === SOURCE) {
+      sources.push(event);
+    }
+    if (event.action === STATE) {
+      states.push(event);
+    }
+  }
+  callback({ sources, states, values });
+}
+
+// ../luna-core/src/handle/source-event.ts
+function handleSourceEvent(selected = null, events = [], setSource) {
+  for (const event of events) {
+    const { target, source } = event;
+    if (!selected) {
+      setSource(target, void 0);
+      continue;
+    }
+    if (isDataSource(source)) {
+      const newUrl = interpolate(source.url, selected);
+      const newBody = source.body ? interpolate(source.body, selected) : source.body;
+      setSource(target, {
+        ...source,
+        url: newUrl,
+        body: newBody
+      });
+    }
+  }
+}
+
+// ../luna-core/src/util/operator.ts
+var operators = {
+  eq,
+  gt,
+  gte,
+  in: includes,
+  lt,
+  lte,
+  neq,
+  nin
+};
+var ISO_DATE_REGEX = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2})?/;
+var DMY_DATE_REGEX = /^(\d{2})[/-](\d{2})[/-](\d{4})(?: (\d{2}):(\d{2})(?::(\d{2}))?)?$/;
+function isISODateString(value) {
+  return typeof value === "string" && ISO_DATE_REGEX.test(value);
+}
+function isDMYDateString(value) {
+  return typeof value === "string" && DMY_DATE_REGEX.test(value);
+}
+function parseDMYDate(value) {
+  const match = value.match(DMY_DATE_REGEX);
+  if (match) {
+    const [, day, month, year, hours, minutes, seconds] = match;
+    return new Date(
+      Number(year),
+      Number(month) - 1,
+      Number(day),
+      Number(hours ?? 0),
+      Number(minutes ?? 0),
+      Number(seconds ?? 0)
+    ).getTime();
+  }
+  return NaN;
+}
+function toComparableNumber(value) {
+  if (isISODateString(value)) {
+    return new Date(value).getTime();
+  }
+  if (isDMYDateString(value)) {
+    return parseDMYDate(value);
+  }
+  return Number(value);
+}
+function eq(current, value) {
+  return current === value;
+}
+function neq(current, value) {
+  return current !== value;
+}
+function includes(current, value) {
+  return Array.isArray(value) && value.includes(String(current));
+}
+function nin(current, value) {
+  return Array.isArray(value) && !value.includes(String(current));
+}
+function gt(current, value) {
+  return toComparableNumber(current) > toComparableNumber(value);
+}
+function gte(current, value) {
+  return toComparableNumber(current) >= toComparableNumber(value);
+}
+function lt(current, value) {
+  return toComparableNumber(current) < toComparableNumber(value);
+}
+function lte(current, value) {
+  return toComparableNumber(current) <= toComparableNumber(value);
+}
+
+// ../luna-core/src/handle/state-event.ts
+function handleStateEvent(selected = null, events = [], setState) {
+  for (const event of events) {
+    const { target, state, when } = event;
+    const targets = Array.isArray(target) ? target : [target];
+    if (!selected) {
+      setState(targets);
+      continue;
+    }
+    const matches = evaluateCondition(selected, when);
+    setState(targets, matches ? state : void 0);
+  }
+}
+function evaluateCondition(selected, when) {
+  if (when === void 0) {
+    return true;
+  }
+  if (isString(when)) {
+    return getValue2(selected, VALUE) === when;
+  }
+  if (isBoolean(when)) {
+    return Boolean(getValue2(selected, VALUE)) === when;
+  }
+  if (Array.isArray(when)) {
+    return when.includes(String(getValue2(selected, VALUE)));
+  }
+  return evaluateOperator(selected, when);
+}
+function evaluateOperator(selected = null, condition) {
+  const current = getValue2(selected, condition.field ?? VALUE);
+  const { operator = "eq", value } = condition;
+  const operation = operators[operator];
+  if (operation) {
+    return operation(current, value);
+  }
+  return false;
+}
+function getValue2(selected, field) {
+  if (isObject(selected)) {
+    return extract(selected, field);
+  }
+  return selected;
+}
+
+// ../luna-core/src/handle/value-event.ts
+function handleValueEvent(selected = null, events = [], setValue) {
+  for (const event of events) {
+    for (const [target, value] of Object.entries(event.value)) {
+      setValue(target, selected ? interpolate(value, selected) : void 0);
+    }
+  }
+}
+
+// ../luna-core/src/util/date.ts
+import { isValid, parse, format as fnsFormat } from "date-fns";
+var REF = new Date(2e3, 0, 1);
+function getCurrentYear() {
+  return (/* @__PURE__ */ new Date()).getFullYear();
+}
+function toNativeDate(value, fromFormat) {
+  if (!value) {
+    return "";
+  }
+  try {
+    const date = parse(value, fromFormat, REF);
+    return isValid(date) ? fnsFormat(date, "yyyy-MM-dd") : "";
+  } catch {
+    return "";
+  }
+}
+function toNativeTime(value, fromFormat) {
+  if (!value) {
+    return "";
+  }
+  try {
+    const date = parse(value, fromFormat, REF);
+    return isValid(date) ? fnsFormat(date, "HH:mm:ss") : "";
+  } catch {
+    return "";
+  }
+}
+function fromNativeDate(native, toFormat = "MMMM d, yyyy") {
+  if (!native) {
+    return "";
+  }
+  try {
+    const date = parse(native, "yyyy-MM-dd", REF);
+    return isValid(date) ? fnsFormat(date, toFormat) : "";
+  } catch {
+    return "";
+  }
+}
+function getTimeFormat(field) {
+  return field.advanced?.format ?? "HH:mm";
+}
+function getDateFormat(field) {
+  return field.advanced?.format ?? "MMMM d, yyyy";
+}
+
+// ../luna-core/src/helper/input.ts
+var now = getCurrentYear();
+function getInputValue(field, value) {
+  const newValue = isObject(value) && field.name in value ? value[field.name] : value;
+  const currentValue = getCurrentValue(newValue, field.advanced?.entity);
+  if (isTime(field) && isValidValue(currentValue)) {
+    return getTimeValue(field, currentValue);
+  }
+  if (isDate(field) && isValidValue(currentValue)) {
+    return getDateValue(field, currentValue);
+  }
+  return currentValue;
+}
+function getTimeValue(field, currentValue) {
+  const format = getTimeFormat(field);
+  return isString(currentValue) ? toNativeTime(currentValue, format) : currentValue;
+}
+function mergeOptionsProps(field, commonProps, options) {
+  return isOptions(field) && Array.isArray(options) ? { ...commonProps, [OPTIONS]: options } : commonProps;
+}
+function getPreselectedValue(field, commonProps, value) {
+  if (field.required && !isValidValue(value)) {
+    if (isSelect(field)) {
+      if (field.advanced?.preselected !== false && OPTIONS in commonProps) {
+        const options = commonProps[OPTIONS];
+        if (Array.isArray(options) && options.length === 1) {
+          return options[0];
+        }
+      }
+    }
+  }
+  return value;
+}
+function getOptions(field, data) {
+  if (isOptions(field) && Array.isArray(data)) {
+    return toOptions(data, field.advanced?.options);
+  }
+  return data;
+}
+function prepareInputProps(field, commonProps, data, value) {
+  const currentValue = getInputValue(field, value);
+  const options = Array.isArray(data) ? getOptions(field, data) : data;
+  const commonPropsWithOptions = mergeOptionsProps(field, commonProps, options);
+  const defaultValue = getPreselectedValue(
+    field,
+    commonPropsWithOptions,
+    currentValue
+  );
+  return {
+    commonPropsWithOptions,
+    defaultValue
+  };
+}
+function prepareInputValue(field, value) {
+  if (isCheckbox(field)) {
+    return {
+      checked: isValidValue(value) ? value : false
+    };
+  }
+  if (isChips(field)) {
+    return { value: Array.isArray(value) ? value : [] };
+  }
+  if (isDate(field)) {
+    if (isString(value) && isValidValue(value)) {
+      return { value: fromNativeDate(value, getDateFormat(field)) };
+    }
+  }
+  return { value: value ?? "" };
+}
+function getDateValue(field, currentValue) {
+  const format = getDateFormat(field);
+  return isString(currentValue) ? toNativeDate(currentValue, format) : currentValue;
+}
+
+// ../luna-core/src/util/schema.ts
+import { z } from "zod";
+
+// ../luna-core/src/util/translate.ts
+function translate(key, dictionary) {
+  if (!key) {
+    return "";
+  }
+  if (!dictionary) {
+    return key;
+  }
+  return dictionary[key] ?? key;
+}
+
+// ../luna-core/src/util/schema.ts
+var approach = [
+  [isNumber, getNumber],
+  [isEmail, getEmail],
+  [isSelectYear, getYearSchema],
+  [isSelectMonth, getMonthSchema],
+  [isCheckbox, getBoolean],
+  [isRadio, getRadio]
+];
+function getSchema(input, translations) {
+  for (const [check, getSchema2] of approach) {
+    if (check(input)) {
+      return getSchema2(input, translations);
+    }
+  }
+  return getText(input, translations);
+}
+function getEmail(input, translations) {
+  const baseSchema = z.string().trim();
+  if (input.required) {
+    const message = getRequiredMessage(input, translations);
+    const schema = baseSchema.min(1, message).pipe(applyEmail(input, translations));
+    return z.preprocess((value) => isEmpty(value) ? "" : value, schema);
+  }
+  return baseSchema.pipe(applyEmail(input, translations)).or(z.literal("")).nullable();
+}
+function getBoolean(input, translations) {
+  let schema = z.coerce.boolean();
+  if (input.required) {
+    schema = schema.refine((value) => value === true, {
+      message: getRequiredMessage(input, translations)
+    });
+    return z.preprocess((value) => value === null ? false : value, schema);
+  }
+  return schema.nullable();
+}
+function getRadio(input, translations) {
+  let schema = z.coerce.string();
+  if (input.required) {
+    schema = schema.min(1, getRequiredMessage(input, translations));
+    return z.preprocess((value) => isEmpty(value) ? "" : value, schema);
+  }
+  return schema.or(z.literal("")).nullable();
+}
+function getText(input, translations) {
+  let schema = z.coerce.string().trim();
+  schema = applyMinAndMax(schema, input, translations);
+  if (input.required) {
+    schema = applyRequired(schema, input, translations);
+    return z.preprocess((value) => isEmpty(value) ? "" : value, schema);
+  }
+  return schema.nullable();
+}
+function getNumber(input, translations) {
+  let schema = z.coerce.number().int();
+  schema = applyMinAndMax(schema, input, translations);
+  if (input.required) {
+    schema = applyRequired(schema, input, translations);
+    return z.preprocess((value) => value === null ? void 0 : value, schema);
+  }
+  return schema.nullable();
+}
+function getYearSchema(input, translations) {
+  if (input.required) {
+    return z.preprocess(
+      normalize,
+      z.coerce.number({ message: getRequiredMessage(input, translations) }).int()
+    );
+  }
+  return z.coerce.number().int().nullable();
+}
+function getMonthSchema(input, translations) {
+  const message = getRequiredMessage(input, translations);
+  const schema = z.coerce.number().int().min(1, message).max(12, message);
+  return !input.required ? schema.nullable() : schema;
+}
+function normalize(value) {
+  return value === null || value === "" ? void 0 : value;
+}
+function applyEmail(input, translations) {
+  const message = input.validation?.email ? translate(input.validation?.email, translations) : void 0;
+  return z.email(message);
+}
+function applyMinAndMax(schema, input, translations) {
+  schema = min(schema, input, translations);
+  schema = max(schema, input, translations);
+  return schema;
+}
+function applyRequired(schema, input, translations) {
+  const min2 = input.advanced?.length?.min;
+  if (min2 === void 0 || min2 < 1) {
+    return schema.min(1, getRequiredMessage(input, translations));
+  }
+  return schema;
+}
+var min = (schema, input, translations) => applyConstraint(schema, input, MIN, translations);
+var max = (schema, input, translations) => applyConstraint(schema, input, MAX, translations);
+function applyConstraint(schema, input, method, translations) {
+  const value = input.advanced?.length?.[method];
+  if (value !== void 0) {
+    const message = input.validation?.length?.[method] ? translate(input.validation?.length?.[method], translations) : void 0;
+    return schema[method](value, message);
+  }
+  return schema;
+}
+function validateCustom(value, rules, getValue3, translations) {
+  const errors = [];
+  const collections = Array.isArray(rules) ? rules : [rules];
+  for (const rule of collections) {
+    const operator = rule.operator ?? "eq";
+    const operation = operators[operator];
+    if (operation && !operation(value, getValue3(rule.field))) {
+      if (rule.message) {
+        const message = translate(rule.message, translations);
+        errors.push(message);
+      }
+    }
+  }
+  return errors;
+}
+function getRequiredMessage(input, translations) {
+  return input.validation?.required ? translate(input.validation?.required, translations) : void 0;
+}
+
+// ../luna-core/src/util/url.ts
+function mergeUrl(baseUrl, targetUrl) {
+  try {
+    if (!baseUrl) {
+      return targetUrl;
+    }
+    if (!targetUrl) {
+      return baseUrl;
+    }
+    const url1 = new URL(baseUrl, COMMON_URL);
+    const url2 = new URL(targetUrl, COMMON_URL);
+    url2.searchParams.forEach((value, key) => {
+      url1.searchParams.set(key, value);
+    });
+    const result = url1.toString();
+    return baseUrl.startsWith("/") || !baseUrl.includes("://") ? result.replace(COMMON_URL, "") : result;
+  } catch {
+    return targetUrl || baseUrl;
+  }
+}
+
+// ../luna-core/src/util/source.ts
+function mergeSource(sources) {
+  if (!Array.isArray(sources) || sources.length === 0) {
+    return null;
+  }
+  return sources.reduce((previous, current) => {
+    const url = mergeUrl(previous.url, current.url);
+    const body = getBody(previous, current);
+    const headers = getHeaders(previous, current);
+    return {
+      ...previous,
+      ...current,
+      url,
+      body,
+      headers
+    };
+  });
+}
+function getBody(previous, current) {
+  if (isObject(current.body) && isObject(previous?.body)) {
+    return {
+      ...previous.body,
+      ...current.body
+    };
+  }
+  return current.body ?? previous?.body;
+}
+function getHeaders(previous, current) {
+  if (isObject(current.headers) && isObject(previous?.headers)) {
+    return {
+      ...previous.headers,
+      ...current.headers
+    };
+  }
+  return current.headers ?? previous?.headers;
+}
+
+// ../luna-core/src/util/load-timezones.ts
+var pending = null;
+function loadTimezones() {
+  const cached = getCachedTimezones();
+  if (cached) {
+    return Promise.resolve(cached);
+  }
+  if (pending) {
+    return pending;
+  }
+  pending = import("./timezone-data-XTIMFTET.js").then(({ TIMEZONE_STATIC }) => {
+    const groups = computeTimezoneGroups(TIMEZONE_STATIC);
+    pending = null;
+    return groups;
+  });
+  return pending;
+}
+
+export {
+  getEntity,
+  interpolateIfNeeded,
+  formatMarkdown,
+  handleProxyEvent,
+  handleSourceEvent,
+  handleStateEvent,
+  handleValueEvent,
+  isSelectTimezone,
+  isCheckbox,
+  isRadio,
+  isClickable,
+  isOptions,
+  isValidValue,
+  prepareInputProps,
+  prepareInputValue,
+  translate,
+  getSchema,
+  validateCustom,
+  mergeSource,
+  getUserTimezone,
+  loadTimezones
+};