@dxos/plugin-deck 0.6.8-main.046e6cf

package/src/layout.test.ts

@@ -0,0 +1,380 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { expect, describe, test } from 'vitest';
+
+import { type LayoutParts, type LayoutAdjustment, type LayoutEntry } from '@dxos/app-framework';
+
+import { uriToActiveParts, activePartsToUri, incrementPlank, mergeLayoutParts, openEntry } from './layout';
+
+describe('Layout URI parsing and formatting', () => {
+  test('uriToActiveParts parses a simple URI correctly', () => {
+    const uri = 'https://composer.space/main-id1~path1+id2_sidebar-id3';
+    const result = uriToActiveParts(uri);
+    expect(result).to.deep.equal({
+      main: [{ id: 'id1', path: 'path1' }, { id: 'id2' }],
+      sidebar: [{ id: 'id3' }],
+    });
+  });
+
+  test('activePartsToUri formats a simple object correctly', () => {
+    const activeParts: LayoutParts = {
+      main: [{ id: 'id1', path: 'path1' }, { id: 'id2' }],
+      sidebar: [{ id: 'id3' }],
+    };
+    const result = activePartsToUri(activeParts);
+    expect(result).to.equal('main-id1~path1+id2_sidebar-id3');
+  });
+
+  test('activePartsToUri handles complex cases with multiple parts, and simple paths', () => {
+    const complexActiveParts: LayoutParts = {
+      main: [{ id: 'id1', path: 'path1' }, { id: 'id2' }, { id: 'id3', path: 'path3' }],
+      sidebar: [{ id: 'id4' }, { id: 'id5', path: 'path5' }],
+      complementary: [{ id: 'id6', path: 'path6' }, { id: 'id7' }],
+    };
+    const result = activePartsToUri(complexActiveParts);
+    expect(result).to.equal('main-id1~path1+id2+id3~path3_sidebar-id4+id5~path5_complementary-id6~path6+id7');
+  });
+
+  test('Round trip: URI to object and back to URI', () => {
+    const originalUri = 'main-id1~path1+id2_sidebar-id3_complementary-id4~path4';
+    const activeParts = uriToActiveParts(originalUri);
+    const resultUri = activePartsToUri(activeParts);
+    expect(resultUri).to.equal(originalUri);
+  });
+
+  test('Round trip: object to URI and back to object', () => {
+    const originalParts: LayoutParts = {
+      main: [{ id: 'id1', path: 'path1' }, { id: 'id2' }],
+      sidebar: [{ id: 'id3' }],
+      complementary: [{ id: 'id4', path: 'path4' }],
+    };
+    const uri = activePartsToUri(originalParts);
+    const resultParts = uriToActiveParts(`https://composer.space/${uri}`);
+    expect(resultParts).to.deep.equal(originalParts);
+  });
+
+  test('uriToActiveParts handles missing parts', () => {
+    const uri = 'https://composer.space/main-id1~path1_sidebar-id2';
+    const result = uriToActiveParts(uri);
+    expect(result).to.deep.equal({
+      main: [{ id: 'id1', path: 'path1' }],
+      sidebar: [{ id: 'id2' }],
+    });
+  });
+
+  test('activePartsToUri excludes empty parts', () => {
+    const activeParts: LayoutParts = {
+      main: [{ id: 'id1', path: 'path1' }],
+    };
+    const result = activePartsToUri(activeParts);
+    expect(result).to.equal('main-id1~path1');
+  });
+});
+
+describe('Layout adjustment', () => {
+  test('adjustLayout moves an item left in the main part', () => {
+    const layout: LayoutParts = {
+      main: [{ id: 'id1' }, { id: 'id2' }, { id: 'id3' }],
+      sidebar: [{ id: 'sid1' }],
+    };
+    const adjustment: LayoutAdjustment = {
+      layoutCoordinate: { part: 'main', entryId: 'id2' },
+      type: 'increment-start',
+    };
+    const result = incrementPlank(layout, adjustment);
+    expect(result.main).to.deep.equal([{ id: 'id2' }, { id: 'id1' }, { id: 'id3' }]);
+    expect(result.sidebar).to.deep.equal([{ id: 'sid1' }]);
+  });
+
+  test('adjustLayout moves an item right in the main part', () => {
+    const layout: LayoutParts = {
+      main: [{ id: 'id1' }, { id: 'id2' }, { id: 'id3' }],
+      sidebar: [{ id: 'sid1' }],
+    };
+    const adjustment: LayoutAdjustment = {
+      layoutCoordinate: { part: 'main', entryId: 'id2' },
+      type: 'increment-end',
+    };
+    const result = incrementPlank(layout, adjustment);
+    expect(result.main).to.deep.equal([{ id: 'id1' }, { id: 'id3' }, { id: 'id2' }]);
+    expect(result.sidebar).to.deep.equal([{ id: 'sid1' }]);
+  });
+
+  test('adjustLayout does not move items in non-main parts', () => {
+    const layout: LayoutParts = {
+      main: [{ id: 'id1' }],
+      sidebar: [{ id: 'sid1' }, { id: 'sid2' }, { id: 'sid3' }],
+    };
+    const adjustment: LayoutAdjustment = {
+      layoutCoordinate: { part: 'sidebar', entryId: 'sid2' },
+      type: 'increment-end',
+    };
+    const result = incrementPlank(layout, adjustment);
+    expect(result).to.deep.equal(layout);
+  });
+
+  test('adjustLayout does not move the first item left in main', () => {
+    const layout: LayoutParts = {
+      main: [{ id: 'id1' }, { id: 'id2' }],
+    };
+    const adjustment: LayoutAdjustment = {
+      layoutCoordinate: { part: 'main', entryId: 'id1' },
+      type: 'increment-start',
+    };
+    const result = incrementPlank(layout, adjustment);
+    expect(result).to.deep.equal(layout);
+  });
+
+  test('adjustLayout does not move the last item right in main', () => {
+    const layout: LayoutParts = {
+      main: [{ id: 'id1' }, { id: 'id2' }],
+    };
+    const adjustment: LayoutAdjustment = {
+      layoutCoordinate: { part: 'main', entryId: 'id2' },
+      type: 'increment-end',
+    };
+    const result = incrementPlank(layout, adjustment);
+    expect(result).to.deep.equal(layout);
+  });
+
+  test('adjustLayout handles non-existent slugId in main', () => {
+    const layout: LayoutParts = {
+      main: [{ id: 'id1' }, { id: 'id2' }],
+    };
+    const adjustment: LayoutAdjustment = {
+      layoutCoordinate: { part: 'main', entryId: 'id3' },
+      type: 'increment-start',
+    };
+    const result = incrementPlank(layout, adjustment);
+    expect(result).to.deep.equal(layout);
+  });
+
+  test('adjustLayout preserves other parts when adjusting main', () => {
+    const layout: LayoutParts = {
+      main: [{ id: 'id1' }, { id: 'id2' }],
+      sidebar: [{ id: 'sid1' }],
+      complementary: [{ id: 'cid1' }],
+    };
+    const adjustment: LayoutAdjustment = {
+      layoutCoordinate: { part: 'main', entryId: 'id2' },
+      type: 'increment-start',
+    };
+    const result = incrementPlank(layout, adjustment);
+    expect(result.main).to.deep.equal([{ id: 'id2' }, { id: 'id1' }]);
+    expect(result.sidebar).to.deep.equal([{ id: 'sid1' }]);
+    expect(result.complementary).to.deep.equal([{ id: 'cid1' }]);
+  });
+
+  test('adjustLayout handles empty main part', () => {
+    const layout: LayoutParts = {
+      main: [],
+      sidebar: [{ id: 'sid1' }],
+    };
+    const adjustment: LayoutAdjustment = {
+      layoutCoordinate: { part: 'main', entryId: 'id1' },
+      type: 'increment-start',
+    };
+    const result = incrementPlank(layout, adjustment);
+    expect(result).to.deep.equal(layout);
+  });
+
+  test('adjustLayout handles undefined main part', () => {
+    const layout: LayoutParts = {
+      sidebar: [{ id: 'sid1' }],
+    };
+    const adjustment: LayoutAdjustment = {
+      layoutCoordinate: { part: 'main', entryId: 'id1' },
+      type: 'increment-start',
+    };
+    const result = incrementPlank(layout, adjustment);
+    expect(result).to.deep.equal(layout);
+  });
+
+  test('adjustLayout handles main part with only one item', () => {
+    const layout: LayoutParts = {
+      main: [{ id: 'id1' }],
+    };
+    const adjustment: LayoutAdjustment = {
+      layoutCoordinate: { part: 'main', entryId: 'id1' },
+      type: 'increment-end',
+    };
+    const result = incrementPlank(layout, adjustment);
+    expect(result).to.deep.equal(layout);
+  });
+});
+
+describe('Layout parts merging', () => {
+  test('merges two simple layout parts', () => {
+    const part1: LayoutParts = { main: [{ id: 'id1' }] };
+    const part2: LayoutParts = { sidebar: [{ id: 'id2' }] };
+    const result = mergeLayoutParts(part1, part2);
+    expect(result).to.deep.equal({
+      main: [{ id: 'id1' }],
+      sidebar: [{ id: 'id2' }],
+    });
+  });
+
+  test('replaces entries with the same id in the same part', () => {
+    const part1: LayoutParts = { main: [{ id: 'id1', path: 'path1' }] };
+    const part2: LayoutParts = { main: [{ id: 'id1', path: 'path2' }] };
+    const result = mergeLayoutParts(part1, part2);
+    expect(result).to.deep.equal({
+      main: [{ id: 'id1', path: 'path2' }],
+    });
+  });
+
+  test('merges multiple layout parts', () => {
+    const part1: LayoutParts = { main: [{ id: 'id1' }] };
+    const part2: LayoutParts = { sidebar: [{ id: 'id2' }] };
+    const part3: LayoutParts = { complementary: [{ id: 'id3' }] };
+    const result = mergeLayoutParts(part1, part2, part3);
+    expect(result).to.deep.equal({
+      main: [{ id: 'id1' }],
+      sidebar: [{ id: 'id2' }],
+      complementary: [{ id: 'id3' }],
+    });
+  });
+
+  test('handles empty layout parts', () => {
+    const part1: LayoutParts = { main: [{ id: 'id1' }] };
+    const part2: LayoutParts = {};
+    const result = mergeLayoutParts(part1, part2);
+    expect(result).to.deep.equal({
+      main: [{ id: 'id1' }],
+    });
+  });
+
+  test('merges parts with multiple entries', () => {
+    const part1: LayoutParts = { main: [{ id: 'id1' }, { id: 'id2' }] };
+    const part2: LayoutParts = { main: [{ id: 'id3' }], sidebar: [{ id: 'id4' }] };
+    const result = mergeLayoutParts(part1, part2);
+    expect(result).to.deep.equal({
+      main: [{ id: 'id1' }, { id: 'id2' }, { id: 'id3' }],
+      sidebar: [{ id: 'id4' }],
+    });
+  });
+
+  test('replaces entries with the same id and keeps unique entries', () => {
+    const part1: LayoutParts = {
+      main: [{ id: 'id1', path: 'path1' }, { id: 'id2' }],
+      sidebar: [{ id: 'id3' }],
+    };
+    const part2: LayoutParts = {
+      main: [{ id: 'id1', path: 'path2' }, { id: 'id4' }],
+      complementary: [{ id: 'id5' }],
+    };
+    const result = mergeLayoutParts(part1, part2);
+    expect(result).to.deep.equal({
+      main: [{ id: 'id1', path: 'path2' }, { id: 'id2' }, { id: 'id4' }],
+      sidebar: [{ id: 'id3' }],
+      complementary: [{ id: 'id5' }],
+    });
+  });
+
+  test('merges complex layout parts', () => {
+    const part1: LayoutParts = {
+      main: [{ id: 'id1', path: 'path1' }, { id: 'id2' }],
+      sidebar: [{ id: 'id3' }],
+    };
+    const part2: LayoutParts = {
+      main: [{ id: 'id1', path: 'path2' }, { id: 'id4' }],
+      complementary: [{ id: 'id5' }],
+    };
+    const part3: LayoutParts = {
+      sidebar: [{ id: 'id6' }],
+      fullScreen: [{ id: 'id7' }],
+    };
+    const result = mergeLayoutParts(part1, part2, part3);
+    expect(result).to.deep.equal({
+      main: [{ id: 'id1', path: 'path2' }, { id: 'id2' }, { id: 'id4' }],
+      sidebar: [{ id: 'id3' }, { id: 'id6' }],
+      complementary: [{ id: 'id5' }],
+      fullScreen: [{ id: 'id7' }],
+    });
+  });
+
+  test('handles merging with duplicate entries in the same part', () => {
+    const part1: LayoutParts = {
+      main: [{ id: 'id1' }, { id: 'id1' }, { id: 'id2' }],
+    };
+    const result = mergeLayoutParts(part1);
+    expect(result).to.deep.equal({
+      main: [{ id: 'id1' }, { id: 'id2' }],
+    });
+  });
+
+  test('preserves order of entries when merging', () => {
+    const part1: LayoutParts = { main: [{ id: 'id1' }, { id: 'id2' }] };
+    const part2: LayoutParts = { main: [{ id: 'id3' }, { id: 'id1' }] };
+    const result = mergeLayoutParts(part1, part2);
+    expect(result).to.deep.equal({
+      main: [{ id: 'id1' }, { id: 'id2' }, { id: 'id3' }],
+    });
+  });
+});
+
+describe('openEntry', () => {
+  const initialLayout: LayoutParts = {
+    main: [
+      { id: 'id1', path: 'path1' },
+      { id: 'id2', path: 'path2' },
+      { id: 'id3', path: 'path3' },
+    ],
+    sidebar: [{ id: 'sid1', path: 'sidepath1' }],
+  };
+
+  const newEntry: LayoutEntry = { id: 'new', path: 'newpath' };
+
+  test('adds entry to start of main without pivot', () => {
+    const result = openEntry(initialLayout, 'main', newEntry, { positioning: 'start' });
+    expect(result.main?.[0]).to.deep.equal(newEntry);
+    expect(result.main?.length).to.equal(4);
+  });
+
+  test('adds entry to end of main without pivot', () => {
+    const result = openEntry(initialLayout, 'main', newEntry, { positioning: 'end' });
+    expect(result.main?.[result.main.length - 1]).to.deep.equal(newEntry);
+    expect(result.main?.length).to.equal(4);
+  });
+
+  test('adds entry before pivot in main', () => {
+    const result = openEntry(initialLayout, 'main', newEntry, { positioning: 'start', pivotId: 'id2' });
+    expect(result.main?.[1]).to.deep.equal(newEntry);
+    expect(result.main?.length).to.equal(4);
+  });
+
+  test('adds entry after pivot in main', () => {
+    const result = openEntry(initialLayout, 'main', newEntry, { positioning: 'end', pivotId: 'id2' });
+    expect(result.main?.[2]).to.deep.equal(newEntry);
+    expect(result.main?.length).to.equal(4);
+  });
+
+  test('adds entry to start when pivot is not found', () => {
+    const result = openEntry(initialLayout, 'main', newEntry, { positioning: 'start', pivotId: 'nonexistent' });
+    expect(result.main?.[0]).to.deep.equal(newEntry);
+    expect(result.main?.length).to.equal(4);
+  });
+
+  test('does not add duplicate entry to main', () => {
+    const result = openEntry(initialLayout, 'main', initialLayout.main![0], { positioning: 'start' });
+    expect(result.main).to.deep.equal(initialLayout.main);
+  });
+
+  test('replaces entry in non-main part', () => {
+    const result = openEntry(initialLayout, 'sidebar', newEntry);
+    expect(result.sidebar).to.deep.equal([newEntry]);
+  });
+
+  test('creates new part if it does not exist', () => {
+    const result = openEntry(initialLayout, 'complementary', newEntry);
+    expect(result.complementary).to.deep.equal([newEntry]);
+  });
+
+  test('handles undefined main part', () => {
+    const layoutWithoutMain: LayoutParts = { sidebar: [{ id: 'sid1', path: 'sidepath1' }] };
+    const result = openEntry(layoutWithoutMain, 'main', newEntry);
+    expect(result.main).to.deep.equal([newEntry]);
+  });
+});

package/src/layout.ts

@@ -0,0 +1,245 @@
+//
+// Copyright 2024 DXOS.org
+//
+import { produce } from 'immer';
+
+import {
+  type LayoutAdjustment,
+  type LayoutCoordinate,
+  type LayoutEntry,
+  type LayoutParts,
+  SLUG_ENTRY_SEPARATOR,
+  SLUG_KEY_VALUE_SEPARATOR,
+  SLUG_LIST_SEPARATOR,
+  SLUG_PATH_SEPARATOR,
+  type LayoutPart,
+} from '@dxos/app-framework';
+
+import { type NewPlankPositioning } from './types';
+
+// Part feature support
+const partsThatSupportIncrement = ['main'] as LayoutPart[];
+
+//
+// --- Layout Parts Manipulation ----------------------------------------------
+
+type OpenLayoutEntryOptions = { positioning?: NewPlankPositioning; pivotId?: string };
+
+export const openEntry = (
+  layout: LayoutParts,
+  part: LayoutPart,
+  entry: LayoutEntry,
+  options?: OpenLayoutEntryOptions,
+): LayoutParts => {
+  return produce(layout, (draft) => {
+    const layoutPart = draft[part];
+    // If the part doesn't exist, create it.
+    if (!layoutPart) {
+      draft[part] = [entry];
+      return;
+    }
+    if (part === 'main') {
+      // Check that the entry is not already in the part
+      if (layoutPart.find((e) => e.id === entry.id)) {
+        return;
+      }
+
+      const plankPositioning = options?.positioning ?? 'start';
+      const pivotId = options?.pivotId;
+
+      if (pivotId) {
+        const pivotIndex = layoutPart.findIndex((e) => e.id === pivotId);
+        if (pivotIndex !== -1) {
+          if (plankPositioning === 'start') {
+            layoutPart.splice(pivotIndex, 0, entry);
+          } else {
+            layoutPart.splice(pivotIndex + 1, 0, entry);
+          }
+          return;
+        }
+      }
+
+      // If no pivot found or provided, fall back to original behavior
+      if (plankPositioning === 'start') {
+        layoutPart.unshift(entry);
+      } else {
+        layoutPart.push(entry);
+      }
+    } else {
+      // If the part is not main, we're going to replace the single entry in the part with the new entry.
+      draft[part] = [entry];
+    }
+  });
+};
+
+export const closeEntry = (layout: LayoutParts, layoutCoordinate: LayoutCoordinate): LayoutParts => {
+  return produce(layout, (draft) => {
+    const { part, entryId: slugId } = layoutCoordinate;
+    const layoutPart = draft[part];
+    if (!layoutPart) {
+      return;
+    }
+
+    const index = layoutPart.findIndex((entry) => entry.id === slugId);
+    if (index === -1) {
+      return;
+    }
+
+    // If there's only one entry in the layout part, remove the whole part from the layout.
+    if (layoutPart.length === 1) {
+      delete draft[part];
+    } else {
+      layoutPart.splice(index, 1);
+    }
+  });
+};
+
+export const incrementPlank = (layout: LayoutParts, adjustment: LayoutAdjustment): LayoutParts => {
+  return produce(layout, (draft) => {
+    const { layoutCoordinate, type } = adjustment;
+    const { part, entryId } = layoutCoordinate;
+
+    // Only allow adjustments in the 'main' part
+    if (partsThatSupportIncrement.includes(part) === false) {
+      return;
+    }
+
+    const layoutPart = draft[part];
+    if (!layoutPart) {
+      return;
+    }
+    const index = layoutPart.findIndex((entry) => entry.id === entryId);
+    if (
+      index === -1 ||
+      (type === 'increment-start' && index === 0) ||
+      (type === 'increment-end' && index === layoutPart.length - 1)
+    ) {
+      return;
+    }
+
+    if (type === 'increment-start') {
+      // Swap the current item with the previous item.
+      [layoutPart[index - 1], layoutPart[index]] = [layoutPart[index], layoutPart[index - 1]];
+    } else if (type === 'increment-end') {
+      // Swap the current item with the next item.
+      [layoutPart[index], layoutPart[index + 1]] = [layoutPart[index + 1], layoutPart[index]];
+    }
+  });
+};
+
+export const removePart = (layout: LayoutParts, part: LayoutPart): LayoutParts => {
+  return produce(layout, (draft) => {
+    delete draft[part];
+  });
+};
+
+export const mergeLayoutParts = (...layoutParts: LayoutParts[]): LayoutParts => {
+  return layoutParts.reduce(
+    (merged, current) =>
+      produce(merged, (draft) => {
+        Object.entries(current).forEach(([part, entries]) => {
+          const typedPart = part as LayoutPart;
+
+          if (!draft[typedPart]) {
+            draft[typedPart] = [];
+          }
+
+          const partEntries = draft[typedPart] as LayoutEntry[];
+
+          entries.forEach((entry) => {
+            const existingIndex = partEntries.findIndex((e) => e.id === entry.id);
+            if (existingIndex !== -1) {
+              partEntries[existingIndex] = entry;
+            } else {
+              partEntries.push(entry);
+            }
+          });
+        });
+      }),
+    {} as LayoutParts,
+  );
+};
+
+//
+// --- URI Projection ---------------------------------------------------------
+const parseLayoutEntry = (itemString: string): LayoutEntry => {
+  // Layout entries are in the form of 'id~path' or just 'id'
+  const [id, path] = itemString.split(SLUG_PATH_SEPARATOR);
+  const entry: LayoutEntry = { id };
+  if (path) {
+    entry.path = path;
+  }
+  return entry;
+};
+
+export const uriToSoloPart = (uri: string): LayoutParts | undefined => {
+  // Now after the domain part, there will be a single ID with an optional path
+  const parts = uri.split('/');
+  const slug = parts[parts.length - 1]; // Take the last part of the URI
+
+  if (slug.length > 0) {
+    return {
+      solo: [parseLayoutEntry(slug)],
+    };
+  }
+
+  return undefined;
+};
+
+export const soloPartToUri = (layout: LayoutParts): string => {
+  const soloPart = layout?.solo;
+  if (!soloPart || soloPart.length === 0) {
+    return '';
+  }
+
+  const entry = soloPart[0];
+  return `${entry.id}${entry.path ? SLUG_PATH_SEPARATOR + entry.path : ''}`;
+};
+
+/**
+ * Converts a URI string into a LayoutParts object.
+ * @deprecated Keeping these as a reference for now. We should remove these once we're sure we don't need them.
+ */
+export const uriToActiveParts = (uri: string): LayoutParts => {
+  const parts = uri.split('/');
+  const slug = parts[parts.length - 1]; // Take the last part of the URI
+
+  if (!slug) {
+    return {}; // Return an empty object if the slug is empty
+  }
+
+  return slug.split(SLUG_ENTRY_SEPARATOR).reduce((acc: LayoutParts, partDescriptor) => {
+    const [part, layoutEntry] = partDescriptor.split(SLUG_KEY_VALUE_SEPARATOR);
+    if (part && layoutEntry) {
+      // TODO(Zan): Remove this cast.
+      acc[part as LayoutPart] = layoutEntry.split(SLUG_LIST_SEPARATOR).map(parseLayoutEntry);
+    }
+    return acc;
+  }, {} as LayoutParts);
+};
+
+const formatLayoutEntry = ({ id, path }: LayoutEntry): string => {
+  // NOTE(Zan): Format = `[SOLO_INDICATOR] ID [PATH_SEPARATOR PATH]`.
+  let entry = '';
+  entry += id;
+  if (path) {
+    entry += `${SLUG_PATH_SEPARATOR}${path}`;
+  }
+  return entry;
+};
+
+const formatPartDescriptor = (part: LayoutPart, layoutEntries: LayoutEntry[]): string => {
+  const formattedEntries = layoutEntries.map(formatLayoutEntry).join(SLUG_LIST_SEPARATOR);
+  return `${part}${SLUG_KEY_VALUE_SEPARATOR}${formattedEntries}`;
+};
+
+/**
+ * Converts a LayoutParts object into a URI string.
+ * @deprecated Keeping these as a reference for now. We should remove these once we're sure we don't need them.
+ */
+export const activePartsToUri = (activeParts: LayoutParts): string => {
+  return Object.entries(activeParts)
+    .filter(([, layoutEntries]) => layoutEntries.length > 0) // Only include non-empty parts
+    .map(([part, layoutEntries]) => formatPartDescriptor(part as LayoutPart, layoutEntries))
+    .join(SLUG_ENTRY_SEPARATOR);
+};

package/src/meta.ts

@@ -0,0 +1,10 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+export const DECK_PLUGIN = 'dxos.org/plugin/deck';
+
+export default {
+  id: DECK_PLUGIN,
+  name: 'Deck',
+};

package/src/translations.ts

@@ -0,0 +1,47 @@
+//
+// Copyright 2023 DXOS.org
+//
+import { DECK_PLUGIN } from './meta';
+
+export default [
+  {
+    'en-US': {
+      [DECK_PLUGIN]: {
+        'main header label': 'Main header',
+        'open navigation sidebar label': 'Open navigation sidebar.',
+        'open complementary sidebar label': 'Open complementary sidebar.',
+        'open settings label': 'Show settings',
+        'plugin error message': 'Content failed to render.',
+        'content fallback message': 'Unsupported',
+        'content fallback description':
+          'No plugin had a response for the address you navigated to. Double-check the URL, and ensure you’ve enabled a plugin that supports the object.',
+        'toggle fullscreen label': 'Toggle fullscreen',
+        'settings show footer label': 'Show footer (experimental)',
+        'settings native redirect label': 'Enable native url redirect (experimental)',
+        'settings custom slots': 'Theme option (experimental)',
+        'settings new plank position start label': 'Start',
+        'settings new plank position end label': 'End',
+        'select new plank positioning placeholder': 'Select new plank positioning',
+        'select new plank positioning label': 'New plank positioning',
+        'undo available label': 'Click to undo previous action.',
+        'undo action label': 'Undo',
+        'undo action alt': 'Undo previous action',
+        'undo close label': 'Dismiss',
+        'open comments label': 'Open comments',
+        'error fallback message': 'Unable to open this item',
+        'plank heading fallback label': 'Untitled',
+        'actions menu label': 'Options',
+        'settings deck label': 'Disable Deck',
+        'reload required message': 'Reload required.',
+        'pending heading': 'Loading…',
+        'insert plank label': 'Open',
+        'solo plank label': 'Solo',
+        'settings overscroll label': 'Plank Overscrolling',
+        'select overscroll placeholder': 'Select plank overscrolling behavior',
+        'settings overscroll centering label': 'Centering',
+        'settings overscroll none label': 'None',
+        'settings flat deck': 'Flatten deck appearance',
+      },
+    },
+  },
+];