@async/db 0.2.0

package/dist/types.d.ts

@@ -0,0 +1,51 @@
+type GeneratedTypesConfig = {
+    cwd: string;
+    types?: {
+        enabled?: boolean;
+        emitComments?: boolean;
+        useReadonly?: boolean;
+        exportRuntimeHelpers?: boolean;
+        outFile?: string | null;
+        commitOutFile?: string | null;
+        [key: string]: unknown;
+    };
+    [key: string]: unknown;
+};
+type SchemaField = {
+    type?: string;
+    required?: boolean;
+    nullable?: boolean;
+    description?: string;
+    values?: unknown[];
+    items?: SchemaField;
+    fields?: Record<string, SchemaField>;
+    variants?: Record<string, SchemaVariant>;
+    additionalProperties?: boolean;
+    [key: string]: unknown;
+};
+type SchemaVariant = {
+    fields?: Record<string, SchemaField>;
+    additionalProperties?: boolean;
+    [key: string]: unknown;
+};
+type SchemaResource = {
+    name: string;
+    kind: string;
+    typeName: string;
+    fields: Record<string, SchemaField>;
+    description?: string;
+    typeFallback?: string;
+    [key: string]: unknown;
+};
+type GenerateTypesOptions = {
+    project?: unknown;
+    outFile?: string;
+};
+type GenerateTypesResult = {
+    content: string;
+    outFiles: string[];
+    diagnostics: unknown[];
+};
+export declare function generateTypes(config: GeneratedTypesConfig, options?: GenerateTypesOptions): Promise<GenerateTypesResult>;
+export declare function renderTypes(resources: SchemaResource[], config: GeneratedTypesConfig): string;
+export {};

package/dist/types.js

@@ -0,0 +1,285 @@
+import path from 'node:path';
+import { writeText } from './fs-utils.js';
+import { pascalCase } from './names.js';
+import { loadProjectSchema } from './schema.js';
+export async function generateTypes(config, options = {}) {
+    const project = (options.project ?? await loadProjectSchema(config));
+    const content = renderTypes(project.resources, config);
+    const outFiles = outputFiles(config, options);
+    for (const outFile of outFiles) {
+        await writeText(outFile, content);
+    }
+    return {
+        content,
+        outFiles,
+        diagnostics: project.diagnostics,
+    };
+}
+export function renderTypes(resources, config) {
+    const lines = [
+        '/* eslint-disable */',
+        '// This file is generated by db. Do not edit by hand.',
+        '',
+    ];
+    const enumAliases = collectEnumAliases(resources);
+    for (const alias of enumAliases) {
+        lines.push(renderEnumAlias(alias), '');
+    }
+    const variantAliases = collectVariantAliases(resources);
+    for (const alias of variantAliases) {
+        lines.push(...renderVariantAlias(alias, config), '');
+    }
+    for (const resource of resources) {
+        if (resource.description && config.types?.emitComments !== false) {
+            lines.push(jsDoc(resource.description));
+        }
+        lines.push(`export type ${resource.typeName} = {`);
+        const fieldEntries = Object.entries(resource.fields ?? {});
+        if (fieldEntries.length === 0 && resource.typeFallback === 'record') {
+            lines.push('  [key: string]: unknown;');
+        }
+        else {
+            for (const [fieldName, field] of fieldEntries) {
+                const fieldLines = renderField(fieldName, field, resource, config, 1);
+                lines.push(...fieldLines);
+            }
+        }
+        lines.push('};', '');
+    }
+    const collectionResources = resources.filter((resource) => resource.kind === 'collection');
+    const documentResources = resources.filter((resource) => resource.kind === 'document');
+    lines.push('export type DbCollections = {');
+    for (const resource of collectionResources) {
+        lines.push(`  ${propertyName(resource.name)}: ${resource.typeName};`);
+    }
+    lines.push('};', '');
+    lines.push('export type DbDocuments = {');
+    for (const resource of documentResources) {
+        lines.push(`  ${propertyName(resource.name)}: ${resource.typeName};`);
+    }
+    lines.push('};', '');
+    lines.push('export type DbTypes = {');
+    lines.push('  collections: DbCollections;');
+    lines.push('  documents: DbDocuments;');
+    lines.push('};');
+    if (config.types?.exportRuntimeHelpers !== false) {
+        lines.push('', 'export type DbCollectionName = keyof DbCollections;', 'export type DbDocumentName = keyof DbDocuments;');
+    }
+    return `${lines.join('\n')}\n`;
+}
+function outputFiles(config, options) {
+    const outFiles = [];
+    if (options.outFile) {
+        outFiles.push(path.resolve(config.cwd, options.outFile));
+        return unique(outFiles);
+    }
+    if (config.types?.outFile) {
+        outFiles.push(config.types.outFile);
+    }
+    if (config.types?.commitOutFile) {
+        outFiles.push(config.types.commitOutFile);
+    }
+    return unique(outFiles);
+}
+function renderField(fieldName, field, resource, config, depth, fieldPath = fieldName) {
+    const lines = [];
+    const indent = '  '.repeat(depth);
+    if (field.description && config.types?.emitComments !== false) {
+        lines.push(`${indent}${jsDoc(field.description, depth)}`);
+    }
+    const readonly = config.types?.useReadonly ? 'readonly ' : '';
+    const optional = field.required ? '' : '?';
+    lines.push(`${indent}${readonly}${propertyName(fieldName)}${optional}: ${typeForField(field, fieldPath, resource, config, depth)};`);
+    return lines;
+}
+function typeForField(field, fieldPath, resource, config, depth) {
+    let type;
+    switch (field.type) {
+        case 'string':
+        case 'datetime':
+            type = 'string';
+            break;
+        case 'number':
+            type = 'number';
+            break;
+        case 'boolean':
+            type = 'boolean';
+            break;
+        case 'enum':
+            type = enumAliasName(resource, fieldPath);
+            break;
+        case 'array':
+            type = `Array<${typeForField(field.items ?? { type: 'unknown' }, `${fieldPath}Item`, resource, config, depth)}>`;
+            break;
+        case 'object':
+            type = field.variants
+                ? variantAliasName(resource, fieldPath)
+                : objectType(field, resource, config, depth, fieldPath);
+            break;
+        case 'unknown':
+        default:
+            type = 'unknown';
+    }
+    return field.nullable ? `${type} | null` : type;
+}
+function objectType(field, resource, config, depth, fieldPath) {
+    const fields = field.fields ?? {};
+    const entries = Object.entries(fields);
+    if (entries.length === 0) {
+        return 'Record<string, unknown>';
+    }
+    const indent = '  '.repeat(depth);
+    const childIndent = '  '.repeat(depth + 1);
+    const readonly = config.types?.useReadonly ? 'readonly ' : '';
+    const lines = ['{'];
+    for (const [fieldName, childField] of entries) {
+        if (childField.description && config.types?.emitComments !== false) {
+            lines.push(`${childIndent}${jsDoc(childField.description, depth + 1)}`);
+        }
+        const optional = childField.required ? '' : '?';
+        lines.push(`${childIndent}${readonly}${propertyName(fieldName)}${optional}: ${typeForField(childField, `${fieldPath}${pascalCase(fieldName)}`, resource, config, depth + 1)};`);
+    }
+    if (field.additionalProperties === true) {
+        lines.push(`${childIndent}[key: string]: unknown;`);
+    }
+    lines.push(`${indent}}`);
+    return lines.join('\n');
+}
+function renderVariantAlias(alias, config) {
+    const lines = [`export type ${alias.name} =`];
+    const entries = Object.entries(alias.variants);
+    for (const [index, [variantName, variant]] of entries.entries()) {
+        const prefix = index === 0 ? '  |' : '  |';
+        lines.push(`${prefix} ${variantObjectType(variantName, variant, alias.resource, config, alias.fieldPath, 2)}`);
+    }
+    return [`${lines.join('\n')};`];
+}
+function renderEnumAlias(alias) {
+    const values = alias.values.map((value) => literalType(value));
+    if (values.length <= 3) {
+        return `export type ${alias.name} = ${values.join(' | ')};`;
+    }
+    return [
+        `export type ${alias.name} =`,
+        ...values.map((value) => `  | ${value}`),
+    ].join('\n') + ';';
+}
+function variantObjectType(variantName, variant, resource, config, fieldPath, depth) {
+    const fields = variant.fields ?? {};
+    const indent = '  '.repeat(depth);
+    const childIndent = '  '.repeat(depth + 1);
+    const readonly = config.types?.useReadonly ? 'readonly ' : '';
+    const lines = ['{'];
+    for (const [fieldName, childField] of Object.entries(fields)) {
+        if (childField.description && config.types?.emitComments !== false) {
+            lines.push(`${childIndent}${jsDoc(childField.description, depth + 1)}`);
+        }
+        const optional = childField.required ? '' : '?';
+        const childPath = `${fieldPath}${pascalCase(fieldName)}`;
+        lines.push(`${childIndent}${readonly}${propertyName(fieldName)}${optional}: ${variantFieldType(childField, fieldName, variantName, resource, config, depth + 1, childPath)};`);
+    }
+    if (variant.additionalProperties === true) {
+        lines.push(`${childIndent}[key: string]: unknown;`);
+    }
+    lines.push(`${indent}}`);
+    return lines.join('\n');
+}
+function variantFieldType(field, fieldName, variantName, resource, config, depth, fieldPath) {
+    if (field.type === 'enum' && field.values?.length === 1 && field.values[0] === variantName) {
+        return literalType(variantName);
+    }
+    return typeForField(field, fieldPath, resource, config, depth);
+}
+function collectEnumAliases(resources) {
+    const aliases = new Map();
+    for (const resource of resources) {
+        for (const [fieldName, field] of Object.entries(resource.fields)) {
+            collectFieldEnumAliases(aliases, resource, fieldName, field);
+        }
+    }
+    return [...aliases.values()];
+}
+function collectFieldEnumAliases(aliases, resource, fieldName, field) {
+    if (field.type === 'enum') {
+        addEnumAlias(aliases, enumAliasName(resource, fieldName), field.values ?? []);
+    }
+    if (field.type === 'object') {
+        for (const [childName, childField] of Object.entries(field.fields ?? {})) {
+            collectFieldEnumAliases(aliases, resource, `${fieldName}${pascalCase(childName)}`, childField);
+        }
+        for (const variant of Object.values(field.variants ?? {})) {
+            for (const [childName, childField] of Object.entries(variant.fields ?? {})) {
+                if (childField.type === 'enum' && childField.values?.length === 1) {
+                    continue;
+                }
+                collectFieldEnumAliases(aliases, resource, `${fieldName}${pascalCase(childName)}`, childField);
+            }
+        }
+    }
+    if (field.type === 'array' && field.items) {
+        collectFieldEnumAliases(aliases, resource, `${fieldName}Item`, field.items);
+    }
+}
+function addEnumAlias(aliases, name, values) {
+    const existing = aliases.get(name);
+    if (!existing) {
+        aliases.set(name, {
+            name,
+            values: [...values],
+        });
+        return;
+    }
+    existing.values = [...new Set([...existing.values, ...values])];
+}
+function collectVariantAliases(resources) {
+    const aliases = [];
+    for (const resource of resources) {
+        for (const [fieldName, field] of Object.entries(resource.fields)) {
+            collectFieldVariantAliases(aliases, resource, fieldName, field);
+        }
+    }
+    return aliases;
+}
+function collectFieldVariantAliases(aliases, resource, fieldName, field) {
+    if (field.type === 'object' && field.variants) {
+        aliases.push({
+            name: variantAliasName(resource, fieldName),
+            resource,
+            fieldPath: fieldName,
+            variants: field.variants,
+        });
+    }
+    if (field.type === 'object') {
+        for (const [childName, childField] of Object.entries(field.fields ?? {})) {
+            collectFieldVariantAliases(aliases, resource, `${fieldName}${pascalCase(childName)}`, childField);
+        }
+        for (const variant of Object.values(field.variants ?? {})) {
+            for (const [childName, childField] of Object.entries(variant.fields ?? {})) {
+                collectFieldVariantAliases(aliases, resource, `${fieldName}${pascalCase(childName)}`, childField);
+            }
+        }
+    }
+    if (field.type === 'array' && field.items) {
+        collectFieldVariantAliases(aliases, resource, `${fieldName}Item`, field.items);
+    }
+}
+function enumAliasName(resource, fieldName) {
+    return `${resource.typeName}${pascalCase(fieldName)}`;
+}
+function variantAliasName(resource, fieldName) {
+    return `${resource.typeName}${pascalCase(fieldName)}`;
+}
+function literalType(value) {
+    return JSON.stringify(value);
+}
+function propertyName(value) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value) ? value : JSON.stringify(value);
+}
+function jsDoc(text, depth = 0) {
+    const indent = '  '.repeat(depth);
+    const escaped = String(text).replaceAll('*/', '* /');
+    return `${indent}/** ${escaped} */`.trimStart();
+}
+function unique(values) {
+    return [...new Set(values.filter(Boolean))];
+}

package/dist/viewer-manifest.d.ts

@@ -0,0 +1 @@
+export { generateViewerManifest, renderViewerManifest } from './features/viewer/manifest.js';

package/dist/viewer-manifest.js

@@ -0,0 +1 @@
+export { generateViewerManifest, renderViewerManifest } from './features/viewer/manifest.js';

package/dist/vite.d.ts

@@ -0,0 +1,59 @@
+import type { DbCacheEventPolicy, DbCacheReadPolicy, DbCacheWritePolicy, DbClient, DbOptions, DbTraceOptions } from './index.d.ts';
+
+export type DbVirtualClient = DbClient & {
+};
+
+export type DbViteClientCacheOptions = boolean | {
+  enabled?: boolean;
+  readPolicy?: DbCacheReadPolicy;
+  writePolicy?: DbCacheWritePolicy;
+  eventPolicy?: DbCacheEventPolicy;
+};
+
+export type DbVitePluginOptions = Pick<DbOptions, 'cwd' | 'configPath' | 'dbDir' | 'sourceDir' | 'stateDir' | 'outputs' | 'schemaOutFile' | 'viewerManifestOutFile' | 'schemaManifest' | 'types' | 'schema' | 'defaults' | 'seed' | 'collections' | 'server' | 'rest' | 'graphql' | 'operations' | 'mock'> & {
+  /** Scoped base for db dev tools. Defaults to "/__db". */
+  apiBase?: string;
+  /** App-facing REST data route alias. Defaults to "/db"; set false to disable. */
+  dataPath?: string | false;
+  /** Serve root REST routes such as "/users" during Vite dev. Defaults to false. */
+  rootRoutes?: boolean;
+  /** Scoped REST resource base. Defaults to "<apiBase>/rest". */
+  restBasePath?: string;
+  /** Scoped GraphQL endpoint. Defaults to "<apiBase>/graphql". */
+  graphqlPath?: string;
+  /** Explicit request trace option. Wins over db.config.mjs server.trace. */
+  trace?: DbTraceOptions;
+  /** Virtual module id for the browser-safe client. Defaults to "virtual:db/client"; false disables it. */
+  clientVirtualModule?: string | false;
+  /** Import specifier used inside the virtual client. Defaults to "@async/db/client". */
+  clientImport?: string;
+  /** Opt the virtual browser client into memory cache behavior during Vite dev. */
+  clientCache?: DbViteClientCacheOptions;
+};
+
+export type ViteLikePlugin = {
+  name: string;
+  apply: 'serve';
+  configureServer(server: {
+    middlewares: {
+      use(middleware: (request: unknown, response: unknown, next: () => void) => void): void;
+    };
+    httpServer?: {
+      once(event: 'close', callback: () => void): void;
+    };
+    config?: {
+      logger?: {
+        warn(message: string): void;
+      };
+    };
+  }): void | Promise<void>;
+  resolveId(id: string): string | null | Promise<string | null>;
+  load(id: string): string | null | Promise<string | null>;
+};
+
+export function dbPlugin(options?: DbVitePluginOptions): ViteLikePlugin;
+
+declare module 'virtual:db/client' {
+  export const client: DbVirtualClient;
+  export default client;
+}

package/dist/vite.js

@@ -0,0 +1 @@
+export { dbPlugin } from './integrations/vite.js';

package/dist/web/json-viewer.d.ts

@@ -0,0 +1,5 @@
+type JsonViewerOptions = {
+    title?: string;
+};
+export declare function renderJsonViewer(value: unknown, options?: JsonViewerOptions): string;
+export {};

package/dist/web/json-viewer.js

@@ -0,0 +1,176 @@
+export function renderJsonViewer(value, options = {}) {
+    const title = options.title ?? 'db JSON';
+    const json = normalizeJsonText(value);
+    const formatted = formatJsonText(json);
+    const compact = compactJsonText(json);
+    return `<!doctype html>
+<html lang="en" data-theme-mode="dark">
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>${escapeHtml(title)}</title>
+  <script src="https://cdn.tailwindcss.com"></script>
+</head>
+<body class="min-h-screen bg-slate-950 text-slate-50 antialiased">
+  <header class="flex flex-wrap items-center justify-between gap-3 border-b border-slate-700 bg-slate-900 px-5 py-4 text-slate-50 sm:flex-nowrap" data-theme-surface="header">
+    <h1 class="m-0 min-w-0 truncate text-base font-bold leading-tight">${escapeHtml(title)}</h1>
+    <div class="flex flex-wrap items-center justify-end gap-2">
+      <div class="inline-flex overflow-hidden rounded-md border border-slate-700 bg-slate-800" aria-label="Theme" data-theme-surface="control">
+        <button class="min-h-9 bg-teal-700 px-3 py-2 text-[13px] font-bold text-white hover:bg-teal-600" type="button" data-theme-choice="dark" aria-pressed="true">Dark</button>
+        <button class="min-h-9 px-3 py-2 text-[13px] font-bold text-slate-50 hover:bg-slate-700" type="button" data-theme-choice="light" aria-pressed="false">Light</button>
+        <button class="min-h-9 px-3 py-2 text-[13px] font-bold text-slate-50 hover:bg-slate-700" type="button" data-theme-choice="system" aria-pressed="false">System</button>
+      </div>
+      <div class="inline-flex overflow-hidden rounded-md border border-slate-700 bg-slate-800" aria-label="Formatting" data-theme-surface="control">
+        <button class="min-h-9 bg-teal-700 px-3 py-2 text-[13px] font-bold text-white hover:bg-teal-600" type="button" data-format-choice="pretty" aria-pressed="true">Pretty</button>
+        <button class="min-h-9 px-3 py-2 text-[13px] font-bold text-slate-50 hover:bg-slate-700" type="button" data-format-choice="raw" aria-pressed="false">Raw</button>
+      </div>
+      <button class="min-h-9 rounded-md border border-slate-700 bg-slate-800 px-3 py-2 text-[13px] font-bold text-slate-50 hover:border-teal-400 hover:bg-slate-700" type="button" id="copy-json">Copy</button>
+      <span class="min-w-16 text-right text-[13px] text-slate-400" id="copy-status"></span>
+    </div>
+  </header>
+  <main class="p-5">
+    <pre class="m-0 min-h-[calc(100vh-112px)] overflow-auto rounded-lg border border-slate-700 bg-slate-900 p-4 font-mono text-[13px] leading-[1.55] text-slate-50 [tab-size:2]" id="json-output">${escapeHtml(formatted)}</pre>
+  </main>
+  <script>
+    const root = document.documentElement;
+    const copyButton = document.getElementById('copy-json');
+    const status = document.getElementById('copy-status');
+    const output = document.getElementById('json-output');
+    const themeButtons = [...document.querySelectorAll('[data-theme-choice]')];
+    const formatButtons = [...document.querySelectorAll('[data-format-choice]')];
+    const formattedJson = ${JSON.stringify(formatted)};
+    const compactJson = ${JSON.stringify(compact)};
+    const systemTheme = window.matchMedia('(prefers-color-scheme: light)');
+    let currentTheme = 'dark';
+    const themedSurfaces = [
+      {
+        element: document.body,
+        dark: ['bg-slate-950', 'text-slate-50'],
+        light: ['bg-slate-50', 'text-slate-950'],
+      },
+      {
+        element: document.querySelector('[data-theme-surface="header"]'),
+        dark: ['border-slate-700', 'bg-slate-900', 'text-slate-50'],
+        light: ['border-slate-200', 'bg-white', 'text-slate-950'],
+      },
+      ...[...document.querySelectorAll('[data-theme-surface="control"]')].map((element) => ({
+        element,
+        dark: ['border-slate-700', 'bg-slate-800'],
+        light: ['border-slate-300', 'bg-slate-100'],
+      })),
+      {
+        element: document.getElementById('copy-json'),
+        dark: ['border-slate-700', 'bg-slate-800', 'text-slate-50', 'hover:border-teal-400', 'hover:bg-slate-700'],
+        light: ['border-slate-300', 'bg-slate-100', 'text-slate-700', 'hover:border-teal-500', 'hover:bg-slate-200'],
+      },
+      {
+        element: document.getElementById('copy-status'),
+        dark: ['text-slate-400'],
+        light: ['text-slate-500'],
+      },
+      {
+        element: output,
+        dark: ['border-slate-700', 'bg-slate-900', 'text-slate-50'],
+        light: ['border-slate-200', 'bg-white', 'text-slate-950'],
+      },
+    ];
+    const activeButtonClasses = ['bg-teal-700', 'text-white', 'hover:bg-teal-600'];
+    const inactiveButtonClasses = ['text-slate-50', 'hover:bg-slate-700', 'text-slate-700', 'hover:bg-slate-200'];
+
+    function applyTheme(mode) {
+      root.dataset.themeMode = mode;
+      currentTheme = mode === 'system'
+        ? (systemTheme.matches ? 'light' : 'dark')
+        : mode;
+      for (const surface of themedSurfaces) {
+        if (!surface.element) {
+          continue;
+        }
+        surface.element.classList.remove(...surface.dark, ...surface.light);
+        surface.element.classList.add(...surface[currentTheme]);
+      }
+      for (const button of themeButtons) {
+        setPressed(button, button.dataset.themeChoice === mode);
+      }
+      for (const button of formatButtons) {
+        setPressed(button, button.getAttribute('aria-pressed') === 'true');
+      }
+    }
+
+    for (const button of themeButtons) {
+      button.addEventListener('click', () => {
+        applyTheme(button.dataset.themeChoice);
+      });
+    }
+
+    systemTheme.addEventListener('change', () => {
+      if (root.dataset.themeMode === 'system') {
+        applyTheme('system');
+      }
+    });
+
+    function setFormat(mode) {
+      output.textContent = mode === 'raw' ? compactJson : formattedJson;
+      for (const button of formatButtons) {
+        setPressed(button, button.dataset.formatChoice === mode);
+      }
+    }
+
+    function setPressed(button, pressed) {
+      button.setAttribute('aria-pressed', String(pressed));
+      button.classList.remove(...activeButtonClasses, ...inactiveButtonClasses);
+      button.classList.add(...(pressed
+        ? activeButtonClasses
+        : currentTheme === 'dark'
+          ? ['text-slate-50', 'hover:bg-slate-700']
+          : ['text-slate-700', 'hover:bg-slate-200']));
+    }
+
+    for (const button of formatButtons) {
+      button.addEventListener('click', () => {
+        setFormat(button.dataset.formatChoice);
+      });
+    }
+
+    copyButton.addEventListener('click', async () => {
+      try {
+        await navigator.clipboard.writeText(output.textContent);
+        status.textContent = 'Copied';
+      } catch {
+        status.textContent = 'Copy failed';
+      }
+      setTimeout(() => {
+        status.textContent = '';
+      }, 1200);
+    });
+  </script>
+</body>
+</html>`;
+}
+function normalizeJsonText(value) {
+    return typeof value === 'string' ? value : JSON.stringify(value);
+}
+function formatJsonText(value) {
+    try {
+        return JSON.stringify(JSON.parse(value), null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function compactJsonText(value) {
+    try {
+        return JSON.stringify(JSON.parse(value));
+    }
+    catch {
+        return String(value);
+    }
+}
+function escapeHtml(value) {
+    return String(value)
+        .replaceAll('&', '&amp;')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll("'", '&#39;');
+}

package/dist/web/viewer.d.ts

@@ -0,0 +1,12 @@
+type DbViewerOptions = {
+    graphqlPath?: string;
+    schemaPath?: string;
+    manifestPath?: string;
+    eventsPath?: string;
+    importPath?: string;
+    restBatchPath?: string;
+    restBasePath?: string;
+    sourceDirLabel?: string;
+};
+export declare function renderDbViewer(options?: DbViewerOptions): string;
+export {};