@fayz-ai/core 0.1.6

package/dist/index.js

@@ -0,0 +1,596 @@
+import { getSupabaseClientOptional } from './chunk-YSBXGHAM.js';
+export { clearGlobalCache, createArchetypeProvider, createCacheStore, createFayzApiProvider, createMockProvider, createSupabaseProvider, getActiveTenantId, getSupabaseClientOptional, globalCache, resolveDataProvider, setActiveTenantId, setGlobalSupabaseClient, stableKey, withCache } from './chunk-YSBXGHAM.js';
+export { clearEntityRegistry, deriveEntityKey, getAllEntities, getEntityByKey, registerEntity } from './chunk-WKZVSKEU.js';
+import { getBlock, getScaffold } from './chunk-KAYQFSR6.js';
+export { PLUGIN_API_VERSION, PluginRuntimeProvider, Registry, blockRegistry, componentRegistry, definePlugin, getBlock, getComponent, getDashboardWidgets, getMetric, getPage, getPlugin, getPluginFactory, getScaffold, getWidgetsForZone, isCustomId, listBlocks, listMetrics, listPluginFactories, listPlugins, metricRegistry, pageRegistry, pluginFactoryRegistry, pluginRegistry, registerBlock, registerComponent, registerMetric, registerPage, registerPlugin, registerPluginFactory, registerScaffold, resolvePluginComponent, resolvePluginRuntime, scaffoldRegistry, usePluginRuntime, usePluginRuntimeOptional } from './chunk-KAYQFSR6.js';
+import { getCurrentLocale } from './chunk-5EAZOMVP.js';
+export { I18nProvider, coreTranslations, getCurrentLocale, mergeTranslations, registerTranslations, setCurrentLocale, setLocaleStore, useI18nConfig, useTranslation } from './chunk-5EAZOMVP.js';
+export { hashRouterAdapter, windowRouterAdapter } from './chunk-Y2C2FBQP.js';
+export { FayzRuntimeError, createFayzRuntimeClient } from './chunk-7RTUHSKY.js';
+import * as React2 from 'react';
+
+// src/types/plugins.ts
+var WidgetZone = {
+  SIDEBAR_BEFORE_NAV: "shell.sidebar.before-nav",
+  SIDEBAR_FOOTER: "shell.sidebar.footer",
+  TOPBAR_START: "shell.topbar.start",
+  TOPBAR_END: "shell.topbar.end",
+  PAGE_BEFORE: "page.before",
+  PAGE_AFTER: "page.after",
+  SETTINGS_BEFORE: "settings.before",
+  SETTINGS_AFTER: "settings.after",
+  FLOATING: "shell.floating"
+};
+
+// src/plugin/createSafeDataProvider.ts
+function createSafeDataProvider(makeSupabase, makeMock) {
+  let resolved = null;
+  const get = () => {
+    if (!resolved) {
+      resolved = getSupabaseClientOptional() ? makeSupabase() : makeMock();
+    }
+    return resolved;
+  };
+  return new Proxy({}, {
+    get: (_target, prop) => (...args) => get()[prop](...args)
+  });
+}
+
+// src/lib/format.ts
+var CURRENCY_BY_LOCALE = {
+  "pt-BR": "BRL",
+  "pt-PT": "EUR",
+  en: "USD",
+  "en-US": "USD",
+  "en-GB": "GBP",
+  es: "EUR"
+};
+var _defaultCurrency = null;
+function setDefaultCurrency(code) {
+  _defaultCurrency = code ?? null;
+}
+function getActiveLocale() {
+  try {
+    return getCurrentLocale() || "en";
+  } catch {
+    return "en";
+  }
+}
+function getDefaultCurrency() {
+  if (_defaultCurrency) return _defaultCurrency;
+  return CURRENCY_BY_LOCALE[getActiveLocale()] ?? "USD";
+}
+function formatCurrency(value, currency) {
+  const num = typeof value === "number" ? value : parseFloat(String(value));
+  if (isNaN(num)) return String(value ?? "");
+  return new Intl.NumberFormat(getActiveLocale(), {
+    style: "currency",
+    currency: currency ?? getDefaultCurrency()
+  }).format(num);
+}
+function formatDate(value) {
+  if (!value) return "";
+  try {
+    return new Intl.DateTimeFormat(getActiveLocale(), { dateStyle: "medium" }).format(new Date(value));
+  } catch {
+    return String(value);
+  }
+}
+function formatDateTime(value) {
+  if (!value) return "";
+  try {
+    return new Intl.DateTimeFormat(getActiveLocale(), { dateStyle: "medium", timeStyle: "short" }).format(new Date(value));
+  } catch {
+    return String(value);
+  }
+}
+
+// src/lib/csv.ts
+function escapeCSVField(value) {
+  if (value == null) return "";
+  const str = String(value);
+  if (str.includes(",") || str.includes('"') || str.includes("\n")) {
+    return `"${str.replace(/"/g, '""')}"`;
+  }
+  return str;
+}
+function buildCSV(columns, rows) {
+  const header = columns.map((c) => escapeCSVField(c.label)).join(",");
+  const body = rows.map(
+    (row) => columns.map((col) => {
+      const raw = row[col.key];
+      const formatted = col.format ? col.format(raw, row) : raw;
+      return escapeCSVField(formatted);
+    }).join(",")
+  );
+  return [header, ...body].join("\n");
+}
+function downloadCSV(csv, filename) {
+  const bom = "\uFEFF";
+  const blob = new Blob([bom + csv], { type: "text/csv;charset=utf-8;" });
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename.endsWith(".csv") ? filename : `${filename}.csv`;
+  a.click();
+  URL.revokeObjectURL(url);
+}
+function exportCSV(columns, rows, filename) {
+  downloadCSV(buildCSV(columns, rows), filename);
+}
+function createEventBus() {
+  const handlers = /* @__PURE__ */ new Map();
+  const bus = {
+    emit(event, payload) {
+      const set = handlers.get(event);
+      if (!set) return;
+      for (const handler of Array.from(set)) {
+        try {
+          handler(payload);
+        } catch (err) {
+          console.error(`[fayz] event handler for "${event}" threw:`, err);
+        }
+      }
+    },
+    on(event, handler) {
+      let set = handlers.get(event);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        handlers.set(event, set);
+      }
+      set.add(handler);
+      return () => bus.off(event, handler);
+    },
+    once(event, handler) {
+      const wrapped = (payload) => {
+        bus.off(event, wrapped);
+        handler(payload);
+      };
+      return bus.on(event, wrapped);
+    },
+    off(event, handler) {
+      handlers.get(event)?.delete(handler);
+    },
+    clear(event) {
+      if (event) handlers.delete(event);
+      else handlers.clear();
+    }
+  };
+  return bus;
+}
+var eventBus = createEventBus();
+function useOnEvent(event, handler, deps = []) {
+  const ref = React2.useRef(handler);
+  ref.current = handler;
+  React2.useEffect(
+    () => eventBus.on(event, (payload) => ref.current(payload)),
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [event, ...deps]
+  );
+}
+function UnknownBlock({ type }) {
+  return React2.createElement(
+    "div",
+    {
+      style: {
+        border: "1px dashed #c026d3",
+        color: "#a21caf",
+        padding: "8px 12px",
+        font: "12px ui-monospace, monospace",
+        borderRadius: 6
+      }
+    },
+    `Unknown block: "${type}"`
+  );
+}
+function BlockRenderer({ node }) {
+  const Comp = getBlock(node.type);
+  const childEls = node.children?.length ? node.children.map(
+    (child, i) => React2.createElement(BlockRenderer, { key: child.id ?? `${child.type}-${i}`, node: child })
+  ) : null;
+  if (!Comp) return React2.createElement(UnknownBlock, { type: node.type });
+  return React2.createElement(Comp, { ...node.props ?? {}, node }, childEls);
+}
+function renderBlocks(nodes) {
+  return nodes.map(
+    (node, i) => React2.createElement(BlockRenderer, { key: node.id ?? `${node.type}-${i}`, node })
+  );
+}
+function BlockChildren({ node }) {
+  if (!node?.children?.length) return null;
+  return renderBlocks(node.children);
+}
+
+// src/manifest/index.ts
+var CURRENT_MANIFEST_VERSION = 2;
+var migrations = /* @__PURE__ */ new Map();
+var supportedBackendProviders = ["supabase", "fayz-api", "fayz-shop", "mock", "custom"];
+var supportedPageSections = /* @__PURE__ */ new Set(["main", "secondary", "settings"]);
+var allowedManifestKeys = /* @__PURE__ */ new Set([
+  "manifestVersion",
+  "id",
+  "name",
+  "backend",
+  "locale",
+  "theme",
+  "permissions",
+  "billing",
+  "entities",
+  "surfaces"
+]);
+var allowedBackendKeys = /* @__PURE__ */ new Set(["provider", "projectRef", "url", "adapterId", "options"]);
+var allowedSurfaceKeys = /* @__PURE__ */ new Set(["scaffold", "options", "plugins", "pages"]);
+var allowedPluginRefKeys = /* @__PURE__ */ new Set(["id", "config", "enabled"]);
+var allowedPageKeys = /* @__PURE__ */ new Set(["path", "label", "icon", "section", "blocks", "entity", "component", "permission"]);
+var allowedPermissionKeys = /* @__PURE__ */ new Set(["feature", "action"]);
+var allowedBlockKeys = /* @__PURE__ */ new Set(["type", "id", "props", "children"]);
+var manifestIdPattern = /^[a-z0-9][a-z0-9-]*$/;
+function registerManifestMigration(fromVersion, fn) {
+  migrations.set(fromVersion, fn);
+}
+function migrateManifest(input) {
+  let m = { ...input };
+  let version = typeof m.manifestVersion === "number" ? m.manifestVersion : 1;
+  if (version > CURRENT_MANIFEST_VERSION) {
+    throw new Error(
+      `Manifest version ${version} is newer than this SDK supports (${CURRENT_MANIFEST_VERSION}). Upgrade @fayz-ai/app-runtime.`
+    );
+  }
+  while (version < CURRENT_MANIFEST_VERSION) {
+    const migrate = migrations.get(version);
+    if (!migrate) {
+      throw new Error(`No manifest migration registered from version ${version}.`);
+    }
+    m = migrate(m);
+    version += 1;
+    m.manifestVersion = version;
+  }
+  return m;
+}
+function validateManifest(m) {
+  const problems = [];
+  const manifest = m;
+  addUnsupportedKeys(manifest, allowedManifestKeys, "manifest", problems);
+  if (!Number.isInteger(manifest.manifestVersion)) {
+    problems.push("manifest.manifestVersion must be an integer");
+  } else if (manifest.manifestVersion !== CURRENT_MANIFEST_VERSION) {
+    problems.push(`manifest.manifestVersion must be ${CURRENT_MANIFEST_VERSION}`);
+  }
+  if (typeof manifest.id !== "string" || !manifest.id.trim()) problems.push("manifest.id is required");
+  else if (!manifestIdPattern.test(manifest.id.trim())) {
+    problems.push("manifest.id must match /^[a-z0-9][a-z0-9-]*$/");
+  }
+  if (typeof manifest.name !== "string" || !manifest.name.trim()) problems.push("manifest.name is required");
+  validateLooseObject(manifest.locale, "manifest.locale", problems);
+  validateLooseObject(manifest.theme, "manifest.theme", problems);
+  validateLooseObject(manifest.permissions, "manifest.permissions", problems);
+  validateLooseObject(manifest.billing, "manifest.billing", problems);
+  if (manifest.entities !== void 0) {
+    if (!Array.isArray(manifest.entities)) {
+      problems.push("manifest.entities must be an array");
+    } else {
+      manifest.entities.forEach((entity, index) => {
+        if (!isRecord(entity)) problems.push(`manifest.entities[${index}] must be an object`);
+      });
+    }
+  }
+  if (manifest.backend !== void 0) {
+    if (!isRecord(manifest.backend)) {
+      problems.push("manifest.backend must be an object");
+    } else {
+      addUnsupportedKeys(manifest.backend, allowedBackendKeys, "manifest.backend", problems);
+      const provider = manifest.backend.provider;
+      if (typeof provider !== "string" || !supportedBackendProviders.includes(provider)) {
+        problems.push(`manifest.backend.provider "${String(provider)}" is not supported`);
+      }
+      validateOptionalNonEmptyString(manifest.backend.projectRef, "manifest.backend.projectRef", problems);
+      validateOptionalNonEmptyString(manifest.backend.url, "manifest.backend.url", problems);
+      if (provider === "custom" && !isNonEmptyString(manifest.backend.adapterId)) {
+        problems.push('manifest.backend.adapterId is required when provider is "custom"');
+      } else if (provider !== "custom") {
+        validateOptionalNonEmptyString(manifest.backend.adapterId, "manifest.backend.adapterId", problems);
+      }
+      validateLooseObject(manifest.backend.options, "manifest.backend.options", problems);
+    }
+  }
+  if (!isRecord(manifest.surfaces) || Object.keys(manifest.surfaces).length === 0) {
+    problems.push("manifest.surfaces must declare at least one surface");
+  } else {
+    for (const [name, surface] of Object.entries(manifest.surfaces)) {
+      validateSurfaceManifest(name, surface, problems);
+    }
+  }
+  return problems;
+}
+function validateSurfaceManifest(name, surface, problems) {
+  if (!isRecord(surface)) {
+    problems.push(`surface "${name}" must be an object`);
+    return;
+  }
+  addUnsupportedKeys(surface, allowedSurfaceKeys, `surface "${name}"`, problems);
+  if (!isNonEmptyString(surface.scaffold)) problems.push(`surface "${name}" is missing a scaffold id`);
+  validateLooseObject(surface.options, `surface "${name}".options`, problems);
+  if (surface.pages !== void 0) {
+    if (!Array.isArray(surface.pages)) {
+      problems.push(`surface "${name}".pages must be an array`);
+    } else {
+      const pagePaths = /* @__PURE__ */ new Set();
+      for (const [index, page] of surface.pages.entries()) {
+        validatePageManifest(name, index, page, pagePaths, problems);
+      }
+    }
+  }
+  if (surface.plugins !== void 0) {
+    if (!Array.isArray(surface.plugins)) {
+      problems.push(`surface "${name}".plugins must be an array`);
+    } else {
+      const pluginIds = /* @__PURE__ */ new Set();
+      for (const [index, plugin] of surface.plugins.entries()) {
+        validatePluginRef(name, index, plugin, pluginIds, problems);
+      }
+    }
+  }
+}
+function validatePageManifest(surfaceName, index, page, pagePaths, problems) {
+  const pageLabel = `surface "${surfaceName}" page #${index + 1}`;
+  if (!isRecord(page)) {
+    problems.push(`${pageLabel} must be an object`);
+    return;
+  }
+  addUnsupportedKeys(page, allowedPageKeys, pageLabel, problems);
+  if (!isNonEmptyString(page.path)) {
+    problems.push(`${pageLabel} has an empty path`);
+  } else {
+    const normalizedPath = page.path.trim();
+    if (pagePaths.has(normalizedPath)) {
+      problems.push(`surface "${surfaceName}" declares duplicate page path "${normalizedPath}"`);
+    } else {
+      pagePaths.add(normalizedPath);
+    }
+  }
+  if (page.label !== void 0 && typeof page.label !== "string") problems.push(`${pageLabel}.label must be a string`);
+  if (page.icon !== void 0 && typeof page.icon !== "string") problems.push(`${pageLabel}.icon must be a string`);
+  if (page.section !== void 0 && (typeof page.section !== "string" || !supportedPageSections.has(page.section))) {
+    problems.push(`${pageLabel}.section must be one of main, secondary, settings`);
+  }
+  if (page.entity !== void 0 && !isNonEmptyString(page.entity)) problems.push(`${pageLabel}.entity must be a non-empty string`);
+  if (page.component !== void 0 && !isNonEmptyString(page.component)) {
+    problems.push(`${pageLabel}.component must be a non-empty string`);
+  }
+  const kinds = [page.blocks, page.entity, page.component].filter((x) => x != null);
+  if (kinds.length !== 1) {
+    problems.push(`${pageLabel} must set exactly one of blocks/entity/component`);
+  }
+  if (page.permission !== void 0) {
+    validatePermission(page.permission, `${pageLabel}.permission`, problems);
+  }
+  if (page.blocks !== void 0) {
+    if (!Array.isArray(page.blocks)) {
+      problems.push(`${pageLabel}.blocks must be an array`);
+    } else {
+      page.blocks.forEach((block, blockIndex) => {
+        validateBlockManifest(block, `${pageLabel}.blocks[${blockIndex}]`, problems);
+      });
+    }
+  }
+}
+function validatePluginRef(surfaceName, index, plugin, pluginIds, problems) {
+  const pluginLabel = `surface "${surfaceName}" plugin #${index + 1}`;
+  if (!isRecord(plugin)) {
+    problems.push(`${pluginLabel} must be an object`);
+    return;
+  }
+  addUnsupportedKeys(plugin, allowedPluginRefKeys, pluginLabel, problems);
+  if (!isNonEmptyString(plugin.id)) {
+    problems.push(`${pluginLabel} has an empty id`);
+  } else {
+    const normalizedId = plugin.id.trim();
+    if (pluginIds.has(normalizedId)) {
+      problems.push(`surface "${surfaceName}" declares duplicate plugin id "${normalizedId}"`);
+    } else {
+      pluginIds.add(normalizedId);
+    }
+  }
+  validateLooseObject(plugin.config, `${pluginLabel}.config`, problems);
+  if (plugin.enabled !== void 0 && typeof plugin.enabled !== "boolean") {
+    problems.push(`${pluginLabel}.enabled must be a boolean`);
+  }
+}
+function validatePermission(permission, path, problems) {
+  if (!isRecord(permission)) {
+    problems.push(`${path} must be an object`);
+    return;
+  }
+  addUnsupportedKeys(permission, allowedPermissionKeys, path, problems);
+  if (!isNonEmptyString(permission.feature)) problems.push(`${path}.feature is required`);
+  if (!isNonEmptyString(permission.action)) problems.push(`${path}.action is required`);
+}
+function validateBlockManifest(block, path, problems) {
+  if (!isRecord(block)) {
+    problems.push(`${path} must be an object`);
+    return;
+  }
+  addUnsupportedKeys(block, allowedBlockKeys, path, problems);
+  if (!isNonEmptyString(block.type)) problems.push(`${path}.type is required`);
+  validateLooseObject(block.props, `${path}.props`, problems);
+  if (block.id !== void 0 && typeof block.id !== "string") problems.push(`${path}.id must be a string`);
+  if (block.children !== void 0) {
+    if (!Array.isArray(block.children)) {
+      problems.push(`${path}.children must be an array`);
+    } else {
+      block.children.forEach((child, index) => validateBlockManifest(child, `${path}.children[${index}]`, problems));
+    }
+  }
+}
+function addUnsupportedKeys(value, allowedKeys, path, problems) {
+  for (const key of Object.keys(value)) {
+    if (!allowedKeys.has(key)) {
+      problems.push(`${path}.${key} is not part of AppManifest v2`);
+    }
+  }
+}
+function validateLooseObject(value, path, problems) {
+  if (value !== void 0 && !isRecord(value)) {
+    problems.push(`${path} must be an object`);
+  }
+}
+function validateOptionalNonEmptyString(value, path, problems) {
+  if (value !== void 0 && !isNonEmptyString(value)) {
+    problems.push(`${path} must be a non-empty string`);
+  }
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+
+// src/manifest/app-manifest.schema.json
+var app_manifest_schema_default = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://fayz.ai/schemas/app-manifest/v2.json",
+  title: "Fayz AppManifest",
+  description: "The canonical, JSON-serializable definition of a Fayz app. Code is referenced by registry id; never inlined.",
+  type: "object",
+  required: ["manifestVersion", "id", "name", "surfaces"],
+  additionalProperties: false,
+  properties: {
+    manifestVersion: {
+      type: "integer",
+      const: 2,
+      description: "Current AppManifest schema version. Older or newer versions require an explicit SDK migration before validation."
+    },
+    id: { type: "string", minLength: 1, pattern: "^[a-z0-9][a-z0-9-]*$" },
+    name: { type: "string", minLength: 1 },
+    backend: {
+      type: "object",
+      additionalProperties: false,
+      required: ["provider"],
+      properties: {
+        provider: { enum: ["supabase", "fayz-api", "fayz-shop", "mock", "custom"] },
+        projectRef: { type: "string", minLength: 1 },
+        url: { type: "string", minLength: 1 },
+        adapterId: { type: "string", minLength: 1 },
+        options: { type: "object" }
+      }
+    },
+    locale: { type: "object" },
+    theme: { type: "object" },
+    permissions: { type: "object" },
+    billing: { type: "object" },
+    entities: { type: "array", items: { type: "object" } },
+    surfaces: {
+      type: "object",
+      minProperties: 1,
+      additionalProperties: { $ref: "#/$defs/surface" }
+    }
+  },
+  $defs: {
+    surface: {
+      type: "object",
+      required: ["scaffold"],
+      additionalProperties: false,
+      properties: {
+        scaffold: { type: "string", minLength: 1 },
+        options: { type: "object" },
+        plugins: { type: "array", items: { $ref: "#/$defs/pluginRef" } },
+        pages: { type: "array", items: { $ref: "#/$defs/page" } }
+      }
+    },
+    pluginRef: {
+      type: "object",
+      required: ["id"],
+      additionalProperties: false,
+      properties: {
+        id: { type: "string", minLength: 1 },
+        config: { type: "object" },
+        enabled: { type: "boolean" }
+      }
+    },
+    page: {
+      type: "object",
+      required: ["path"],
+      additionalProperties: false,
+      description: "Exactly one of blocks/entity/component must be set.",
+      properties: {
+        path: { type: "string", minLength: 1 },
+        label: { type: "string" },
+        icon: { type: "string" },
+        section: { enum: ["main", "secondary", "settings"] },
+        blocks: { type: "array", items: { $ref: "#/$defs/block" } },
+        entity: { type: "string", minLength: 1 },
+        component: { type: "string", minLength: 1 },
+        permission: {
+          type: "object",
+          required: ["feature", "action"],
+          additionalProperties: false,
+          properties: {
+            feature: { type: "string", minLength: 1 },
+            action: { type: "string", minLength: 1 }
+          }
+        }
+      },
+      oneOf: [
+        { required: ["blocks"] },
+        { required: ["entity"] },
+        { required: ["component"] }
+      ]
+    },
+    block: {
+      type: "object",
+      required: ["type"],
+      additionalProperties: false,
+      properties: {
+        type: { type: "string", minLength: 1 },
+        id: { type: "string" },
+        props: { type: "object" },
+        children: { type: "array", items: { $ref: "#/$defs/block" } }
+      }
+    }
+  }
+};
+var ManifestContext = React2.createContext(null);
+function useManifest() {
+  return React2.useContext(ManifestContext);
+}
+function defineApp(manifest) {
+  const full = {
+    ...manifest,
+    manifestVersion: manifest.manifestVersion ?? CURRENT_MANIFEST_VERSION
+  };
+  const problems = validateManifest(full);
+  if (problems.length) {
+    throw new Error(`Invalid AppManifest:
+ - ${problems.join("\n - ")}`);
+  }
+  return full;
+}
+function renderApp(input, opts = {}) {
+  const manifest = migrateManifest(input);
+  const problems = validateManifest(manifest);
+  if (problems.length) {
+    throw new Error(`Invalid AppManifest:
+ - ${problems.join("\n - ")}`);
+  }
+  const surfaceName = opts.surface ?? Object.keys(manifest.surfaces)[0];
+  const surface = surfaceName ? manifest.surfaces[surfaceName] : void 0;
+  if (!surface) {
+    throw new Error(`Surface "${surfaceName}" not found in manifest.`);
+  }
+  const Scaffold = getScaffold(surface.scaffold);
+  if (!Scaffold) {
+    throw new Error(
+      `Scaffold "${surface.scaffold}" is not registered. Import the package that provides it (e.g. @fayz-ai/saas or @fayz-ai/shop) before calling renderApp.`
+    );
+  }
+  return React2.createElement(
+    ManifestContext.Provider,
+    { value: manifest },
+    React2.createElement(Scaffold, { manifest, surface: surfaceName })
+  );
+}
+
+export { BlockChildren, BlockRenderer, CURRENT_MANIFEST_VERSION, WidgetZone, app_manifest_schema_default as appManifestSchema, buildCSV, createEventBus, createSafeDataProvider, defineApp, downloadCSV, eventBus, exportCSV, formatCurrency, formatDate, formatDateTime, getActiveLocale, getDefaultCurrency, migrateManifest, registerManifestMigration, renderApp, renderBlocks, setDefaultCurrency, useManifest, useOnEvent, validateManifest };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map