@dxos/plugin-deck 0.7.5-main.9d26e3a → 0.7.5-main.b19bfc8

package/src/layout.ts

@@ -4,245 +4,76 @@
 
 import { produce } from 'immer';
 
-import {
-  type LayoutAdjustment,
-  type LayoutCoordinate,
-  type LayoutEntry,
-  type LayoutPart,
-  type LayoutParts,
-  SLUG_ENTRY_SEPARATOR,
-  SLUG_KEY_VALUE_SEPARATOR,
-  SLUG_LIST_SEPARATOR,
-  SLUG_PATH_SEPARATOR,
-} from '@dxos/app-framework';
+import { type DeckAction, type NewPlankPositioning } from './types';
 
-import { type NewPlankPositioning } from './types';
+type OpenLayoutEntryOptions = { key?: string; positioning?: NewPlankPositioning; pivotId?: string };
 
-// 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];
+export const openEntry = (deck: string[], entryId: string, options?: OpenLayoutEntryOptions): string[] => {
+  return produce(deck, (draft) => {
+    // Check that the entry is not already in the part
+    if (draft.find((id) => id === entryId)) {
       return;
     }
-    if (part === 'main') {
-      // Check that the entry is not already in the part
-      if (layoutPart.find((e) => e.id === entry.id)) {
+
+    const key = options?.key;
+    const plankPositioning = options?.positioning ?? 'start';
+    const pivotId = options?.pivotId;
+
+    if (key) {
+      const index = draft.findIndex((id) => id.split('+')[0] === key);
+      if (index !== -1) {
+        draft.splice(index, 1, entryId);
         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 (pivotId) {
+      const pivotIndex = draft.findIndex((id) => id === pivotId);
+      if (pivotIndex !== -1) {
+        if (plankPositioning === 'start') {
+          draft.splice(pivotIndex, 0, entryId);
+        } else {
+          draft.splice(pivotIndex + 1, 0, entryId);
         }
+        return;
       }
+    }
 
-      // If no pivot found or provided, fall back to original behavior
-      if (plankPositioning === 'start') {
-        layoutPart.unshift(entry);
-      } else {
-        layoutPart.push(entry);
-      }
+    // If no pivot found or provided, fall back to original behavior
+    if (plankPositioning === 'start') {
+      draft.unshift(entryId);
     } 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];
+      draft.push(entryId);
     }
   });
 };
 
-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 closeEntry = (deck: string[], entryId: string): string[] => {
+  return produce(deck, (draft) => {
+    const index = draft.findIndex((id) => id === entryId);
+    if (index !== -1) {
+      draft.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);
+export const incrementPlank = (deck: string[], adjustment: DeckAction.Adjustment): string[] => {
+  return produce(deck, (draft) => {
+    const index = draft.findIndex((id) => id === adjustment.id);
     if (
       index === -1 ||
-      (type === 'increment-start' && index === 0) ||
-      (type === 'increment-end' && index === layoutPart.length - 1)
+      (adjustment.type === 'increment-start' && index === 0) ||
+      (adjustment.type === 'increment-end' && index === draft.length - 1)
     ) {
       return;
     }
 
-    if (type === 'increment-start') {
+    if (adjustment.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') {
+      [draft[index - 1], draft[index]] = [draft[index], draft[index - 1]];
+    } else if (adjustment.type === 'increment-end') {
       // Swap the current item with the next item.
-      [layoutPart[index], layoutPart[index + 1]] = [layoutPart[index + 1], layoutPart[index]];
+      [draft[index], draft[index + 1]] = [draft[index + 1], draft[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

@@ -4,9 +4,10 @@
 
 import { type PluginMeta } from '@dxos/app-framework';
 
-export const DECK_PLUGIN = 'dxos.org/plugin/deck';
+export const DECK_PLUGIN = 'dxos.org/plugin/deck' as const;
 
-export default {
+export const meta = {
   id: DECK_PLUGIN,
   name: 'Deck',
+  icon: 'ph--columns--regular',
 } satisfies PluginMeta;

package/src/translations.ts

@@ -8,9 +8,12 @@ export default [
   {
     'en-US': {
       [DECK_PLUGIN]: {
+        'plugin name': 'Deck',
         'main header label': 'Main header',
-        'open navigation sidebar label': 'Open navigation sidebar',
-        'open complementary sidebar label': 'Open sidebar',
+        'open navigation sidebar label': 'Open sidebar',
+        'collapse navigation sidebar label': 'Minimize sidebar',
+        'open complementary sidebar label': 'Open context sidebar',
+        'close complementary sidebar label': 'Minimize context sidebar',
         'plugin error message': 'Content failed to render.',
         'content fallback message': 'Unsupported',
         'content fallback description':
@@ -18,7 +21,6 @@ export default [
         'toggle fullscreen label': 'Toggle fullscreen',
         'settings show hints label': 'Show hints',
         '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',
@@ -30,7 +32,7 @@ export default [
         'error fallback message': 'Unable to open this item',
         'plank heading fallback label': 'Untitled',
         'actions menu label': 'Options',
-        'settings deck label': 'Disable Deck',
+        'settings deck label': 'Disable deck',
         'reload required message': 'Reload required.',
         'pending heading': 'Loading…',
         'insert plank label': 'Open',
@@ -43,11 +45,11 @@ export default [
         'show solo plank label': 'Maximize',
         'close label': 'Close',
         'minify label': 'Minify',
-        'settings overscroll label': 'Plank Overscrolling',
+        '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',
+        'settings enable ide-style statusbar label': 'IDE-style statusbar',
         'close current label': 'Close current plank',
         'close others label': 'Close other planks',
         'close all label': 'Close all planks',

package/src/types.ts

@@ -2,17 +2,9 @@
 // Copyright 2023 DXOS.org
 //
 
-import type {
-  Plugin,
-  GraphBuilderProvides,
-  IntentResolverProvides,
-  LayoutProvides,
-  LocationProvides,
-  SettingsProvides,
-  SurfaceProvides,
-  TranslationsProvides,
-} from '@dxos/app-framework';
+import { LayoutAction } from '@dxos/app-framework';
 import { S } from '@dxos/echo-schema';
+import { type Node } from '@dxos/plugin-graph';
 import { type Label } from '@dxos/react-ui';
 
 import { DECK_PLUGIN } from './meta';
@@ -24,40 +16,116 @@ export type NewPlankPositioning = (typeof NewPlankPositions)[number];
 export const OverscrollOptions = ['none', 'centering'] as const;
 export type Overscroll = (typeof OverscrollOptions)[number];
 
-// TODO(wittjosiah): Include a predicate for whether the panel is visible for the current subject.
-export type Panel = { id: string; label: Label; icon: string };
-
-// TODO(wittjosiah): Is this generic enough to be in the app framework?
-export type PanelProvides = {
-  complementary: {
-    panels: Panel[];
-  };
+export type Panel = {
+  id: string;
+  label: Label;
+  icon: string;
+  filter?: (node: Node) => boolean;
 };
 
-export const parsePanelPlugin = (plugin?: Plugin) =>
-  Array.isArray((plugin?.provides as any).complementary?.panels) ? (plugin as Plugin<PanelProvides>) : undefined;
-
-export type DeckSettingsProps = {
-  showHints: boolean;
-  customSlots: boolean;
-  flatDeck: boolean;
-  enableNativeRedirect: boolean;
-  disableDeck: boolean;
-  newPlankPositioning: NewPlankPositioning;
-  overscroll: Overscroll;
+export const DeckSettingsSchema = S.mutable(
+  S.Struct({
+    showHints: S.Boolean,
+    enableNativeRedirect: S.Boolean,
+    enableIdeStyleStatusbar: S.Boolean,
+    newPlankPositioning: S.Literal(...NewPlankPositions),
+    overscroll: S.Literal(...OverscrollOptions),
+  }),
+);
+
+export type DeckSettingsProps = S.Schema.Type<typeof DeckSettingsSchema>;
+
+const LayoutMode = S.Union(S.Literal('deck'), S.Literal('solo'), S.Literal('fullscreen'));
+export const isLayoutMode = (value: any): value is LayoutMode => S.is(LayoutMode)(value);
+export type LayoutMode = S.Schema.Type<typeof LayoutMode>;
+
+export const PlankSizing = S.Record({ key: S.String, value: S.Number });
+export type PlankSizing = S.Schema.Type<typeof PlankSizing>;
+
+export const Deck = S.Struct({
+  initialized: S.Boolean.annotations({
+    description: "If false, the deck has not yet left solo mode and new planks should be solo'd.",
+  }),
+  active: S.mutable(S.Array(S.String)),
+  inactive: S.mutable(S.Array(S.String)),
+  solo: S.optional(S.String),
+  fullscreen: S.Boolean,
+  plankSizing: S.mutable(PlankSizing),
+});
+export type Deck = S.Schema.Type<typeof Deck>;
+
+export const DeckState = S.mutable(
+  S.Struct({
+    sidebarState: S.Literal('closed', 'collapsed', 'expanded'),
+    complementarySidebarState: S.Literal('closed', 'collapsed', 'expanded'),
+    complementarySidebarPanel: S.optional(S.String),
+
+    dialogOpen: S.Boolean,
+    /**
+     * Data to be passed to the dialog Surface.
+     */
+    dialogContent: S.optional(S.Any),
+    dialogBlockAlign: S.optional(S.Literal('start', 'center', 'end')),
+    dialogType: S.optional(S.Literal('default', 'alert')),
+
+    popoverOpen: S.Boolean,
+    popoverSide: S.optional(S.Literal('top', 'right', 'bottom', 'left')),
+    /**
+     * Data to be passed to the popover Surface.
+     */
+    popoverContent: S.optional(S.Any),
+    popoverAnchorId: S.optional(S.String),
+
+    toasts: S.mutable(S.Array(LayoutAction.Toast)),
+    currentUndoId: S.optional(S.String),
+
+    activeDeck: S.String,
+    previousDeck: S.String,
+    decks: S.mutable(S.Record({ key: S.String, value: S.mutable(Deck) })),
+    previousMode: S.mutable(S.Record({ key: S.String, value: LayoutMode })),
+    deck: S.mutable(Deck),
+
+    /**
+     * The identifier of a component to scroll into view when it is mounted.
+     */
+    scrollIntoView: S.optional(S.String),
+  }),
+);
+
+export type DeckState = S.Schema.Type<typeof DeckState>;
+
+export const getMode = (deck: Deck): LayoutMode => {
+  if (deck.solo) {
+    return deck.fullscreen ? 'fullscreen' : 'solo';
+  }
+
+  return 'deck';
 };
 
-export type DeckPluginProvides = SurfaceProvides &
-  IntentResolverProvides &
-  GraphBuilderProvides &
-  TranslationsProvides &
-  SettingsProvides<DeckSettingsProps> &
-  LayoutProvides &
-  LocationProvides;
+// NOTE: Chosen from RFC 1738’s `safe` characters: http://www.faqs.org/rfcs/rfc1738.html
+export const SLUG_PATH_SEPARATOR = '~';
 
 export const DECK_ACTION = `${DECK_PLUGIN}/action`;
 
 export namespace DeckAction {
+  const PartAdjustmentSchema = S.Union(
+    S.Literal('close').annotations({ description: 'Close the plank.' }),
+    S.Literal('solo').annotations({ description: 'Solo the plank.' }),
+    S.Literal('increment-start').annotations({ description: 'Move the plank towards the start of the deck.' }),
+    S.Literal('increment-end').annotations({ description: 'Move the plank towards the end of the deck.' }),
+  );
+  export type PartAdjustment = S.Schema.Type<typeof PartAdjustmentSchema>;
+  export const Adjustment = S.mutable(S.Struct({ id: S.String, type: PartAdjustmentSchema }));
+  export type Adjustment = S.Schema.Type<typeof Adjustment>;
+
+  /**
+   * An atomic transaction to apply to the deck, describing which element to move to which location.
+   */
+  export class Adjust extends S.TaggedClass<Adjust>()(`${DECK_ACTION}/adjust`, {
+    input: Adjustment,
+    output: S.Void,
+  }) {}
+
   export class UpdatePlankSize extends S.TaggedClass<UpdatePlankSize>()(`${DECK_ACTION}/update-plank-size`, {
     input: S.Struct({
       id: S.String,

package/src/util/index.ts

@@ -2,6 +2,8 @@
 // Copyright 2024 DXOS.org
 //
 
-export * from './check-app-scheme';
-export * from './layout-parts';
 export * from './overscroll';
+export * from './set-active';
+export * from './useBreakpoints';
+export * from './layoutAppliesTopbar';
+export * from './useHoistStatusbar';

package/src/util/layoutAppliesTopbar.ts

@@ -0,0 +1,7 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+export const layoutAppliesTopbar = (breakpoint: string) => {
+  return document.body.getAttribute('data-platform') === 'win' && breakpoint === 'desktop';
+};

package/src/util/set-active.ts

@@ -0,0 +1,47 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { batch } from '@preact/signals-core';
+
+import { type AttentionManager } from '@dxos/plugin-attention';
+
+import { type DeckState } from '../types';
+
+export type SetActiveOptions = {
+  next: string[];
+  state: DeckState;
+  attention?: AttentionManager;
+};
+
+export const setActive = ({ next, state, attention }: SetActiveOptions) => {
+  return batch(() => {
+    const active = state.deck.solo ? [state.deck.solo] : state.deck.active;
+    const removed = active.filter((id) => !next.includes(id));
+    const closed = Array.from(new Set([...state.deck.inactive.filter((id) => !next.includes(id)), ...removed]));
+
+    state.deck.inactive = closed;
+
+    if (state.deck.solo || !state.deck.initialized) {
+      state.deck.solo = next[0];
+    } else {
+      state.deck.active = next;
+    }
+
+    if (state.deck.fullscreen && !state.deck.solo) {
+      state.deck.fullscreen = false;
+    }
+
+    if (attention) {
+      const attended = attention.current;
+      const [attendedId] = Array.from(attended);
+      const isAttendedAvailable = !!attendedId && next.includes(attendedId);
+      if (!isAttendedAvailable) {
+        const attendedIndex = active.indexOf(attendedId);
+        // If outside of bounds, focus on the first/last plank, otherwise focus on the new plank in the same position.
+        const index = attendedIndex === -1 ? 0 : attendedIndex >= next.length ? next.length - 1 : attendedIndex;
+        return next[index];
+      }
+    }
+  });
+};

package/src/util/useBreakpoints.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useMediaQuery } from '@dxos/react-ui';
+
+export const useBreakpoints = () => {
+  const [isNotMobile] = useMediaQuery('md');
+  const [isDesktop] = useMediaQuery('lg');
+  return isDesktop ? 'desktop' : isNotMobile ? 'tablet' : 'mobile';
+};

package/src/util/useHoistStatusbar.ts

@@ -0,0 +1,20 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useMemo } from 'react';
+
+import { Capabilities, useCapability } from '@dxos/app-framework';
+import { useThemeContext } from '@dxos/react-ui';
+
+import { DECK_PLUGIN } from '../meta';
+import type { DeckSettingsProps } from '../types';
+
+export const useHoistStatusbar = (breakpoint: string) => {
+  const enableIdeStyleStatusbar = useCapability(Capabilities.SettingsStore).getStore<DeckSettingsProps>(DECK_PLUGIN)!
+    .value.enableIdeStyleStatusbar;
+  const { safeAreaPadding } = useThemeContext();
+  return useMemo(() => {
+    return breakpoint === 'desktop' && enableIdeStyleStatusbar && safeAreaPadding?.bottom === 0;
+  }, [enableIdeStyleStatusbar, breakpoint, safeAreaPadding?.bottom]);
+};

package/dist/lib/browser/chunk-GVOGPULO.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/meta.ts"],
-  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport { type PluginMeta } from '@dxos/app-framework';\n\nexport const DECK_PLUGIN = 'dxos.org/plugin/deck';\n\nexport default {\n  id: DECK_PLUGIN,\n  name: 'Deck',\n} satisfies PluginMeta;\n"],
-  "mappings": ";AAMO,IAAMA,cAAc;AAE3B,IAAA,eAAe;EACbC,IAAID;EACJE,MAAM;AACR;",
-  "names": ["DECK_PLUGIN", "id", "name"]
-}

package/dist/lib/browser/chunk-ZC3K6C2W.mjs

@@ -1,37 +0,0 @@
-import {
-  DECK_PLUGIN
-} from "./chunk-GVOGPULO.mjs";
-
-// packages/plugins/plugin-deck/src/types.ts
-import { S } from "@dxos/echo-schema";
-var NewPlankPositions = [
-  "start",
-  "end"
-];
-var OverscrollOptions = [
-  "none",
-  "centering"
-];
-var parsePanelPlugin = (plugin) => Array.isArray(plugin?.provides.complementary?.panels) ? plugin : void 0;
-var DECK_ACTION = `${DECK_PLUGIN}/action`;
-var DeckAction;
-(function(DeckAction2) {
-  class UpdatePlankSize extends S.TaggedClass()(`${DECK_ACTION}/update-plank-size`, {
-    input: S.Struct({
-      id: S.String,
-      size: S.Number
-    }),
-    output: S.Void
-  }) {
-  }
-  DeckAction2.UpdatePlankSize = UpdatePlankSize;
-})(DeckAction || (DeckAction = {}));
-
-export {
-  NewPlankPositions,
-  OverscrollOptions,
-  parsePanelPlugin,
-  DECK_ACTION,
-  DeckAction
-};
-//# sourceMappingURL=chunk-ZC3K6C2W.mjs.map

package/dist/lib/browser/chunk-ZC3K6C2W.mjs.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/types.ts"],
-  "sourcesContent": ["//\n// Copyright 2023 DXOS.org\n//\n\nimport type {\n  Plugin,\n  GraphBuilderProvides,\n  IntentResolverProvides,\n  LayoutProvides,\n  LocationProvides,\n  SettingsProvides,\n  SurfaceProvides,\n  TranslationsProvides,\n} from '@dxos/app-framework';\nimport { S } from '@dxos/echo-schema';\nimport { type Label } from '@dxos/react-ui';\n\nimport { DECK_PLUGIN } from './meta';\n\n// TODO(Zan): In the future we should consider adding new planks adjacent to the attended plank.\nexport const NewPlankPositions = ['start', 'end'] as const;\nexport type NewPlankPositioning = (typeof NewPlankPositions)[number];\n\nexport const OverscrollOptions = ['none', 'centering'] as const;\nexport type Overscroll = (typeof OverscrollOptions)[number];\n\n// TODO(wittjosiah): Include a predicate for whether the panel is visible for the current subject.\nexport type Panel = { id: string; label: Label; icon: string };\n\n// TODO(wittjosiah): Is this generic enough to be in the app framework?\nexport type PanelProvides = {\n  complementary: {\n    panels: Panel[];\n  };\n};\n\nexport const parsePanelPlugin = (plugin?: Plugin) =>\n  Array.isArray((plugin?.provides as any).complementary?.panels) ? (plugin as Plugin<PanelProvides>) : undefined;\n\nexport type DeckSettingsProps = {\n  showHints: boolean;\n  customSlots: boolean;\n  flatDeck: boolean;\n  enableNativeRedirect: boolean;\n  disableDeck: boolean;\n  newPlankPositioning: NewPlankPositioning;\n  overscroll: Overscroll;\n};\n\nexport type DeckPluginProvides = SurfaceProvides &\n  IntentResolverProvides &\n  GraphBuilderProvides &\n  TranslationsProvides &\n  SettingsProvides<DeckSettingsProps> &\n  LayoutProvides &\n  LocationProvides;\n\nexport const DECK_ACTION = `${DECK_PLUGIN}/action`;\n\nexport namespace DeckAction {\n  export class UpdatePlankSize extends S.TaggedClass<UpdatePlankSize>()(`${DECK_ACTION}/update-plank-size`, {\n    input: S.Struct({\n      id: S.String,\n      size: S.Number,\n    }),\n    output: S.Void,\n  }) {}\n}\n"],
-  "mappings": ";;;;;AAcA,SAASA,SAAS;AAMX,IAAMC,oBAAoB;EAAC;EAAS;;AAGpC,IAAMC,oBAAoB;EAAC;EAAQ;;AAanC,IAAMC,mBAAmB,CAACC,WAC/BC,MAAMC,QAASF,QAAQG,SAAiBC,eAAeC,MAAAA,IAAWL,SAAmCM;AAoBhG,IAAMC,cAAc,GAAGC,WAAAA;;UAEbC,aAAAA;EACR,MAAMC,wBAAwBC,EAAEC,YAAW,EAAoB,GAAGL,WAAAA,sBAAiC;IACxGM,OAAOF,EAAEG,OAAO;MACdC,IAAIJ,EAAEK;MACNC,MAAMN,EAAEO;IACV,CAAA;IACAC,QAAQR,EAAES;EACZ,CAAA,EAAA;EAAI;cANSV,kBAAAA;AAOf,GARiBD,eAAAA,aAAAA,CAAAA,EAAAA;",
-  "names": ["S", "NewPlankPositions", "OverscrollOptions", "parsePanelPlugin", "plugin", "Array", "isArray", "provides", "complementary", "panels", "undefined", "DECK_ACTION", "DECK_PLUGIN", "DeckAction", "UpdatePlankSize", "S", "TaggedClass", "input", "Struct", "id", "String", "size", "Number", "output", "Void"]
-}