@dxos/plugin-space 0.8.4-main.70d3990 → 0.8.4-main.74a063c4e0

package/src/types/form.ts

@@ -2,74 +2,9 @@
 // Copyright 2025 DXOS.org
 //
 
-import * as Option from 'effect/Option';
-import * as Schema from 'effect/Schema';
-
-import { type Client } from '@dxos/client';
-import { type Space } from '@dxos/client/echo';
-import { Type } from '@dxos/echo';
-import { EntityKind, SystemTypeAnnotation, createAnnotationHelper, getTypeAnnotation } from '@dxos/echo/internal';
-
-export const TypeInputOptions = Schema.Struct({
-  location: Schema.Array(Schema.Literal('database', 'runtime')),
-  kind: Schema.Array(Schema.Literal('system', 'user')),
-  registered: Schema.Array(Schema.Literal('registered', 'unregistered')),
-});
-
-export type TypeInputOptions = Schema.Schema.Type<typeof TypeInputOptions>;
-
-/**
- * Used in forms to identify the field representing an object's type and determine which types are shown as options.
- */
-export const TypeInputOptionsAnnotationId = Symbol.for('@dxos/schema/annotation/TypeInputOptions');
-export const TypeInputOptionsAnnotation = createAnnotationHelper<TypeInputOptions>(TypeInputOptionsAnnotationId);
-
-// TODO(wittjosiah): This is way to complicated and needs to be simplified.
-export const getTypenames = ({
-  annotation,
-  space,
-  client,
-}: {
-  annotation: TypeInputOptions;
-  space?: Space;
-  client: Client;
-}) => {
-  const includeRuntime = annotation.location.includes('runtime');
-  const includeDatabase = annotation.location.includes('database');
-  const includeSystemType = annotation.kind.includes('system');
-  const includeUserType = annotation.kind.includes('user');
-  const includeRegistered = annotation.registered.includes('registered');
-  const includeUnregistered = annotation.registered.includes('unregistered');
-
-  const runtimeTypenames = includeRuntime
-    ? client.graph.schemaRegistry.schemas
-        .filter((schema) => {
-          const relation = getTypeAnnotation(schema)?.kind === EntityKind.Relation;
-          if (relation) {
-            return includeSystemType;
-          }
-
-          const system = SystemTypeAnnotation.get(schema).pipe(Option.getOrElse(() => false));
-          if (system) {
-            return includeSystemType;
-          }
-
-          return includeUserType;
-        })
-        .filter((schema) => {
-          const registered = space?.properties.staticRecords?.includes(Type.getTypename(schema));
-          return registered ? includeRegistered : includeUnregistered;
-        })
-        .map((schema) => Type.getTypename(schema))
-    : [];
-
-  const databaseTypenames =
-    includeDatabase && includeRegistered && space
-      ? space.db.schemaRegistry
-          .query()
-          .runSync()
-          .map((schema) => schema.typename)
-      : [];
-
-  return Array.from(new Set<string>([...runtimeTypenames, ...databaseTypenames])).sort();
-};
+export {
+  getTypenames,
+  TypeInputOptions,
+  TypeInputOptionsAnnotation,
+  TypeInputOptionsAnnotationId,
+} from '@dxos/app-toolkit';

package/src/types/index.ts

@@ -2,5 +2,7 @@
 // Copyright 2024 DXOS.org
 //
 
+export * from './capabilities';
+export * from './events';
 export * from './form';
 export * from './types';

package/src/types/types.ts

@@ -2,24 +2,50 @@
 // Copyright 2023 DXOS.org
 //
 
+import * as Effect from 'effect/Effect';
 import * as Schema from 'effect/Schema';
 
-import { type AnyIntentChain } from '@dxos/app-framework';
-import { type Obj, QueryAST, Type } from '@dxos/echo';
-import { type PublicKey } from '@dxos/react-client';
-// TODO(wittjosiah): This pulls in full client.
-import { EchoObjectSchema, ReactiveObjectSchema, type Space, SpaceSchema } from '@dxos/react-client/echo';
-import { CancellableInvitationObservable, Invitation } from '@dxos/react-client/invitations';
-import { Collection, FieldSchema, View } from '@dxos/schema';
+import { Capability } from '@dxos/app-framework';
+import { type PublicKey } from '@dxos/client';
+import { Database, Obj } from '@dxos/echo';
+import { Collection } from '@dxos/echo';
+import { Operation } from '@dxos/operation';
 import { type ComplexMap } from '@dxos/util';
 
-import { meta } from '../meta';
+import { meta } from '#meta';
 
-import { TypeInputOptionsAnnotation } from './form';
+export * as Settings from './Settings';
 
-export const SPACE_DIRECTORY_HANDLE = `${meta.id}/directory`;
+export const SPACE_DIRECTORY_HANDLE = `${meta.id}.directory`;
 
-export const SPACE_TYPE = 'dxos.org/type/Space';
+export const SPACE_TYPE = 'org.dxos.type.space';
+
+/** Key for the Expando that stores cross-space ordering (must stay stable for persisted data). */
+export const SHARED = 'shared-spaces';
+
+export type SpacePluginOptions = {
+  /**
+   * Origin used for shareable links (object copy-link and invitation base).
+   * Defaults to window.location.origin.
+   */
+  shareableLinkOrigin?: string;
+
+  /**
+   * Path appended to shareableLinkOrigin to form the invitation base URL.
+   * Defaults to '/'.
+   */
+  invitationPath?: string;
+
+  /**
+   * Query parameter name for the invitation code.
+   */
+  invitationProp?: string;
+
+  /**
+   * Whether to send observability events.
+   */
+  observability?: boolean;
+};
 
 export type ObjectViewerProps = {
   lastSeen: number;
@@ -68,22 +94,11 @@ export type PluginState = {
   enabledEdgeReplication: boolean;
 };
 
-export const SpaceSettingsSchema = Schema.mutable(
-  Schema.Struct({
-    /**
-     * Show closed spaces.
-     */
-    showHidden: Schema.Boolean,
-  }),
-);
-
-export type SpaceSettingsProps = Schema.Schema.Type<typeof SpaceSettingsSchema>;
-
 // TODO(wittjosiah): Reconcile with graph export serializers.
 
 export type SerializerMap = Record<string, TypedObjectSerializer>;
 
-export interface TypedObjectSerializer<T extends Obj.Any = Obj.Any> {
+export interface TypedObjectSerializer<T extends Obj.Unknown = Obj.Unknown> {
   serialize(params: { object: T }): Promise<string>;
 
   /**
@@ -91,290 +106,39 @@ export interface TypedObjectSerializer<T extends Obj.Any = Obj.Any> {
    * @param params.space Space to use for deserializing schema references.
    * @param params.newId Generate new ID for deserialized object.
    */
-  deserialize(params: { content: string; space: Space; newId?: boolean }): Promise<T>;
+  deserialize(params: { content: string; db: Database.Database; newId?: boolean }): Promise<T>;
 }
 
-export type CreateObjectIntent = (props: any, options: { space: Space }) => AnyIntentChain;
+/**
+ * Result of creating and adding an object.
+ */
+export type CreateObjectResult = {
+  id: string;
+  subject: readonly string[];
+  object: Obj.Unknown;
+};
+
+/**
+ * Factory function that creates an object and adds it to a target (database or collection).
+ * Returns an Effect that resolves to the created object result with navigation subject.
+ */
+export type CreateObject = (
+  props: any,
+  options: {
+    db: Database.Database;
+    target: Database.Database | Collection.Collection;
+    targetNodeId?: string;
+  },
+) => Effect.Effect<CreateObjectResult, Error, Capability.Service | Operation.Service>;
 
 // TODO(burdon): Move to FormatEnum or SDK.
 export const IconAnnotationId = Symbol.for('@dxos/plugin-space/annotation/Icon');
 export const HueAnnotationId = Symbol.for('@dxos/plugin-space/annotation/Hue');
 
+// TOOD(burdon): Use SpacePropertiesSchema.
 export const SpaceForm = Schema.Struct({
   name: Schema.optional(Schema.String.annotations({ title: 'Name' })),
   icon: Schema.optional(Schema.String.annotations({ title: 'Icon', [IconAnnotationId]: true })),
   hue: Schema.optional(Schema.String.annotations({ title: 'Color', [HueAnnotationId]: true })),
-  // TODO(wittjosiah): Make optional with default value.
-  edgeReplication: Schema.Boolean.annotations({ title: 'Enable EDGE Replication' }),
+  edgeReplication: Schema.optional(Schema.Boolean.annotations({ title: 'Enable EDGE Replication' })),
 });
-
-export const SPACE_ACTION = `${meta.id}/action`;
-
-export namespace SpaceAction {
-  export class OpenCreateSpace extends Schema.TaggedClass<OpenCreateSpace>()(`${SPACE_ACTION}/open-create-space`, {
-    input: Schema.Void,
-    output: Schema.Void,
-  }) {}
-
-  export class Create extends Schema.TaggedClass<Create>()(`${SPACE_ACTION}/create`, {
-    input: SpaceForm,
-    output: Schema.Struct({
-      id: Schema.String,
-      subject: Schema.Array(Schema.String),
-      space: SpaceSchema,
-    }),
-  }) {}
-
-  export class Join extends Schema.TaggedClass<Join>()(`${SPACE_ACTION}/join`, {
-    input: Schema.Struct({
-      invitationCode: Schema.optional(Schema.String),
-      onDone: Schema.optional(Schema.Any),
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class OpenMembers extends Schema.TaggedClass<OpenMembers>()(`${SPACE_ACTION}/open-members`, {
-    input: Schema.Struct({
-      space: SpaceSchema,
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class Share extends Schema.TaggedClass<Share>()(`${SPACE_ACTION}/share`, {
-    input: Schema.Struct({
-      space: SpaceSchema,
-      type: Schema.Enums(Invitation.Type),
-      authMethod: Schema.Enums(Invitation.AuthMethod),
-      multiUse: Schema.Boolean,
-      target: Schema.optional(Schema.String),
-    }),
-    output: Schema.instanceOf(CancellableInvitationObservable),
-  }) {}
-
-  export class GetShareLink extends Schema.TaggedClass<GetShareLink>()(`${SPACE_ACTION}/get-share-link`, {
-    input: Schema.Struct({
-      space: SpaceSchema,
-      target: Schema.optional(Schema.String),
-      copyToClipboard: Schema.optional(Schema.Boolean),
-    }),
-    output: Schema.String,
-  }) {}
-
-  export class Lock extends Schema.TaggedClass<Lock>()(`${SPACE_ACTION}/lock`, {
-    input: Schema.Struct({
-      space: SpaceSchema,
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class Unlock extends Schema.TaggedClass<Unlock>()(`${SPACE_ACTION}/unlock`, {
-    input: Schema.Struct({
-      space: SpaceSchema,
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class Rename extends Schema.TaggedClass<Rename>()(`${SPACE_ACTION}/rename`, {
-    input: Schema.Struct({
-      space: SpaceSchema,
-      caller: Schema.optional(Schema.String),
-    }),
-    output: Schema.Void,
-  }) {}
-
-  // TODO(wittjosiah): Handle scrolling to section.
-  //   This maybe motivates making the space settings its own deck?
-  export class OpenSettings extends Schema.TaggedClass<OpenSettings>()(`${SPACE_ACTION}/open-settings`, {
-    input: Schema.Struct({ space: SpaceSchema }),
-    output: Schema.Void,
-  }) {}
-
-  export class Open extends Schema.TaggedClass<Open>()(`${SPACE_ACTION}/open`, {
-    input: Schema.Struct({
-      space: SpaceSchema,
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class Close extends Schema.TaggedClass<Close>()(`${SPACE_ACTION}/close`, {
-    input: Schema.Struct({
-      space: SpaceSchema,
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class Migrate extends Schema.TaggedClass<Migrate>()(`${SPACE_ACTION}/migrate`, {
-    input: Schema.Struct({
-      space: SpaceSchema,
-      version: Schema.optional(Schema.String),
-    }),
-    output: Schema.Boolean,
-  }) {}
-
-  export class Snapshot extends Schema.TaggedClass<Snapshot>()(`${SPACE_ACTION}/snapshot`, {
-    input: Schema.Struct({
-      space: SpaceSchema,
-      query: QueryAST.Query.pipe(Schema.optional),
-    }),
-    output: Schema.Struct({
-      snapshot: Schema.instanceOf(Blob),
-    }),
-  }) {}
-
-  export const StoredSchemaForm = Schema.Struct({
-    name: Schema.optional(Schema.String),
-    typename: Schema.String.pipe(
-      Schema.annotations({ title: 'Select type (leave blank to create a new type)' }),
-      TypeInputOptionsAnnotation.set({
-        location: ['runtime'],
-        kind: ['user'],
-        registered: ['unregistered'],
-      }),
-      Schema.optional,
-    ),
-  });
-
-  export class UseStaticSchema extends Schema.TaggedClass<UseStaticSchema>()(`${SPACE_ACTION}/use-static-schema`, {
-    input: Schema.Struct({
-      space: SpaceSchema,
-      typename: Schema.String,
-      // TODO(wittjosiah): This is leaky.
-      show: Schema.optional(Schema.Boolean),
-    }),
-    output: Schema.Struct({}),
-  }) {}
-
-  export class AddSchema extends Schema.TaggedClass<AddSchema>()(`${SPACE_ACTION}/add-schema`, {
-    input: Schema.Struct({
-      space: SpaceSchema,
-      name: Schema.optional(Schema.String),
-      typename: Schema.optional(Schema.String),
-      // TODO(wittjosiah): Semantic version format.
-      version: Schema.optional(Schema.String),
-      // TODO(wittjosiah): Schema for schema?
-      schema: Schema.Any,
-      // TODO(wittjosiah): This is leaky.
-      show: Schema.optional(Schema.Boolean),
-    }),
-    output: Schema.Struct({
-      // TODO(wittjosiah): ObjectId.
-      id: Schema.String,
-      object: Type.PersistentType,
-      schema: Schema.instanceOf(Type.RuntimeType),
-    }),
-  }) {}
-
-  export class DeleteField extends Schema.TaggedClass<DeleteField>()(`${SPACE_ACTION}/delete-field`, {
-    input: Schema.Struct({
-      view: View.View,
-      fieldId: Schema.String,
-      // TODO(wittjosiah): Separate fields for undo data?
-      deletionData: Schema.optional(
-        Schema.Struct({
-          field: FieldSchema,
-          // TODO(wittjosiah): This creates a type error.
-          // props: PropertySchema,
-          props: Schema.Any,
-          index: Schema.Number,
-        }),
-      ),
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class OpenCreateObject extends Schema.TaggedClass<OpenCreateObject>()(`${SPACE_ACTION}/open-create-object`, {
-    input: Schema.Struct({
-      target: Schema.Union(SpaceSchema, Collection.Collection),
-      views: Schema.optional(Schema.Boolean),
-      typename: Schema.optional(Schema.String),
-      initialFormValues: Schema.optional(Schema.Any),
-      navigable: Schema.optional(Schema.Boolean),
-      // TODO(wittjosiah): This is a function, is there a better way to handle this?
-      onCreateObject: Schema.optional(Schema.Any),
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class AddObject extends Schema.TaggedClass<AddObject>()(`${SPACE_ACTION}/add-object`, {
-    input: Schema.Struct({
-      object: ReactiveObjectSchema,
-      target: Schema.Union(SpaceSchema, Collection.Collection),
-      hidden: Schema.optional(Schema.Boolean),
-    }),
-    output: Schema.Struct({
-      // TODO(wittjosiah): ObjectId.
-      id: Schema.String,
-      subject: Schema.Array(Schema.String),
-      object: EchoObjectSchema,
-    }),
-  }) {}
-
-  export class AddRelation extends Schema.TaggedClass<AddRelation>()(`${SPACE_ACTION}/add-relation`, {
-    input: Schema.Struct({
-      space: SpaceSchema,
-      // TODO(wittjosiah): Relation schema.
-      schema: Schema.Any,
-      source: Type.Expando,
-      target: Type.Expando,
-      // TODO(wittjosiah): Type based on relation schema.
-      fields: Schema.optional(Schema.Record({ key: Schema.String, value: Schema.Any })),
-    }),
-    output: Schema.Struct({
-      relation: Schema.Any,
-    }),
-  }) {}
-
-  export const DeletionData = Schema.Struct({
-    objects: Schema.Array(EchoObjectSchema),
-    parentCollection: Collection.Collection,
-    indices: Schema.Array(Schema.Number),
-    nestedObjectsList: Schema.Array(Schema.Array(EchoObjectSchema)),
-    wasActive: Schema.Array(Schema.String),
-  });
-
-  export type DeletionData = Schema.Schema.Type<typeof DeletionData>;
-
-  export class RemoveObjects extends Schema.TaggedClass<RemoveObjects>()(`${SPACE_ACTION}/remove-objects`, {
-    input: Schema.Struct({
-      // TODO(wittjosiah): Should be Schema.Union(Type.Obj, Type.Relation).
-      objects: Schema.Array(ReactiveObjectSchema),
-      target: Schema.optional(Collection.Collection),
-      deletionData: Schema.optional(DeletionData),
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class RenameObject extends Schema.TaggedClass<RenameObject>()(`${SPACE_ACTION}/rename-object`, {
-    input: Schema.Struct({
-      object: EchoObjectSchema,
-      caller: Schema.optional(Schema.String),
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class DuplicateObject extends Schema.TaggedClass<DuplicateObject>()(`${SPACE_ACTION}/duplicate-object`, {
-    input: Schema.Struct({
-      object: EchoObjectSchema,
-      target: Schema.Union(SpaceSchema, Collection.Collection),
-    }),
-    output: Schema.Void,
-  }) {}
-
-  export class WaitForObject extends Schema.TaggedClass<WaitForObject>()(`${SPACE_ACTION}/wait-for-object`, {
-    input: Schema.Struct({
-      id: Schema.optional(Schema.String),
-    }),
-    output: Schema.Void,
-  }) {}
-}
-
-export namespace CollectionAction {
-  export class Create extends Schema.TaggedClass<Create>()('dxos.org/plugin/collection/action/create', {
-    input: Schema.Struct({
-      name: Schema.optional(Schema.String),
-    }),
-    output: Schema.Struct({
-      object: Collection.Collection,
-    }),
-  }) {}
-}

package/src/util.ts

@@ -0,0 +1,79 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Space, SpaceState } from '@dxos/client/echo';
+import { type Database, Obj, Type } from '@dxos/echo';
+import { invariant } from '@dxos/invariant';
+import { Expando } from '@dxos/schema';
+import { type Label } from '@dxos/ui-types';
+
+import { meta } from '#meta';
+
+//
+// Constants
+//
+
+const PERSONAL_SPACE_LABEL: Label = ['personal-space.label', { ns: meta.id }];
+const UNNAMED_SPACE_LABEL: Label = ['unnamed-space.label', { ns: meta.id }];
+
+export const SPACES = `${meta.id}-spaces`;
+export { SHARED } from './types';
+
+//
+// Helpers
+//
+
+/** Returns the display label for a space (name, namesCache entry, or fallback). */
+export const getSpaceDisplayName = (
+  space: Space,
+  { personal, namesCache = {} }: { personal?: boolean; namesCache?: Record<string, string> } = {},
+): Label => {
+  return space.state.get() === SpaceState.SPACE_READY && (space.properties.name?.length ?? 0) > 0
+    ? space.properties.name!
+    : namesCache[space.id]
+      ? namesCache[space.id]
+      : personal
+        ? PERSONAL_SPACE_LABEL
+        : UNNAMED_SPACE_LABEL;
+};
+
+//
+// Deprecated
+//
+
+/** @deprecated This is a temporary solution. */
+export const getNestedObjects = async (
+  object: Obj.Unknown,
+  resolve: (typename: string) => Record<string, any>,
+): Promise<Obj.Unknown[]> => {
+  const type = Obj.getTypename(object);
+  if (!type) {
+    return [];
+  }
+
+  const metadata = resolve(type);
+  const loadReferences = metadata?.loadReferences;
+  if (typeof loadReferences !== 'function') {
+    return [];
+  }
+
+  const objects: Obj.Unknown[] = await loadReferences(object);
+  const nested = await Promise.all(objects.map((object) => getNestedObjects(object, resolve)));
+  return [...objects, ...nested.flat()];
+};
+
+/** @deprecated Workaround for ECHO not supporting clone. */
+export const cloneObject = async (
+  object: Obj.Unknown,
+  resolve: (typename: string) => Record<string, any>,
+  newDb: Database.Database,
+): Promise<Obj.Unknown> => {
+  const schema = Obj.getSchema(object);
+  const typename = schema ? (Type.getTypename(schema) ?? Expando.Expando.typename) : Expando.Expando.typename;
+  const metadata = resolve(typename);
+  const serializer = metadata.serializer;
+  invariant(serializer, `No serializer for type: ${typename}`);
+  const content = await serializer.serialize({ object });
+  return serializer.deserialize({ content, db: newDb, newId: true });
+};

package/dist/lib/browser/CollectionArticle-WTHWY4YS.mjs

@@ -1,31 +0,0 @@
-import {
-  meta
-} from "./chunk-VZBIIYFM.mjs";
-
-// src/components/CollectionArticle.tsx
-import { useSignals as _useSignals } from "@preact-signals/safe-react/tracking";
-import React from "react";
-import { useTranslation } from "@dxos/react-ui";
-import { baseSurface, descriptionMessage, mx } from "@dxos/react-ui-theme";
-var CollectionArticle = ({ subject }) => {
-  var _effect = _useSignals();
-  try {
-    const { t } = useTranslation(meta.id);
-    return /* @__PURE__ */ React.createElement("div", {
-      role: "none",
-      className: mx(baseSurface, "min-bs-screen is-full flex items-center justify-center p-8"),
-      "data-testid": "composer.firstRunMessage"
-    }, /* @__PURE__ */ React.createElement("p", {
-      role: "alert",
-      className: mx(descriptionMessage, "rounded-md p-8 font-normal text-lg max-is-[24rem] break-words")
-    }, subject.name ?? t("unnamed collection label")));
-  } finally {
-    _effect.f();
-  }
-};
-var CollectionArticle_default = CollectionArticle;
-export {
-  CollectionArticle,
-  CollectionArticle_default as default
-};
-//# sourceMappingURL=CollectionArticle-WTHWY4YS.mjs.map

package/dist/lib/browser/CollectionArticle-WTHWY4YS.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/components/CollectionArticle.tsx"],
-  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport React from 'react';\n\nimport { type SurfaceComponentProps } from '@dxos/app-framework/react';\nimport { useTranslation } from '@dxos/react-ui';\nimport { baseSurface, descriptionMessage, mx } from '@dxos/react-ui-theme';\nimport { type Collection } from '@dxos/schema';\n\nimport { meta } from '../meta';\n\nexport const CollectionArticle = ({ subject }: SurfaceComponentProps<Collection.Collection>) => {\n  const { t } = useTranslation(meta.id);\n\n  return (\n    <div\n      role='none'\n      className={mx(baseSurface, 'min-bs-screen is-full flex items-center justify-center p-8')}\n      data-testid='composer.firstRunMessage'\n    >\n      <p\n        role='alert'\n        className={mx(descriptionMessage, 'rounded-md p-8 font-normal text-lg max-is-[24rem] break-words')}\n      >\n        {subject.name ?? t('unnamed collection label')}\n      </p>\n    </div>\n  );\n};\n\nexport default CollectionArticle;\n"],
-  "mappings": ";;;;;;AAIA,OAAOA,WAAW;AAGlB,SAASC,sBAAsB;AAC/B,SAASC,aAAaC,oBAAoBC,UAAU;AAK7C,IAAMC,oBAAoB,CAAC,EAAEC,QAAO,MAAgD;;;AACzF,UAAM,EAAEC,EAAC,IAAKC,eAAeC,KAAKC,EAAE;AAEpC,WACE,sBAAA,cAACC,OAAAA;MACCC,MAAK;MACLC,WAAWC,GAAGC,aAAa,4DAAA;MAC3BC,eAAY;OAEZ,sBAAA,cAACC,KAAAA;MACCL,MAAK;MACLC,WAAWC,GAAGI,oBAAoB,+DAAA;OAEjCZ,QAAQa,QAAQZ,EAAE,0BAAA,CAAA,CAAA;;;;AAI3B;AAEA,IAAA,4BAAeF;",
-  "names": ["React", "useTranslation", "baseSurface", "descriptionMessage", "mx", "CollectionArticle", "subject", "t", "useTranslation", "meta", "id", "div", "role", "className", "mx", "baseSurface", "data-testid", "p", "descriptionMessage", "name"]
-}