@mappedin/viewer 0.14.2 → 0.14.3-0fc3c2d.0

package/dist/types/App.d.ts

@@ -2,7 +2,7 @@
 import './lib/i18n';
 import './fonts.css';
 import { TStartViewerOptions, TStartViewerWithLocalDataOptions } from './lib/types/options';
-import '@mappedin/mappedin-js/lib/mappedin.css';
+import '@mappedin/maker-sdk/lib/index.css';
 declare const App: ((options: TStartViewerOptions | TStartViewerWithLocalDataOptions) => import("react").JSX.Element) & {
     displayName: string;
 };

package/dist/types/components/button/index.d.ts

@@ -56,7 +56,7 @@ declare const Button: import("styled-components").IStyledComponent<"web", import
     results?: number | undefined;
     security?: string | undefined;
     unselectable?: "on" | "off" | undefined;
-    inputMode?: "search" | "text" | "none" | "tel" | "url" | "email" | "numeric" | "decimal" | undefined;
+    inputMode?: "search" | "text" | "url" | "none" | "tel" | "email" | "numeric" | "decimal" | undefined;
     is?: string | undefined;
     'aria-activedescendant'?: string | undefined;
     'aria-atomic'?: (boolean | "true" | "false") | undefined;

package/dist/types/components/common/fullscreen-overlay.d.ts

@@ -0,0 +1,274 @@
+/// <reference types="react" />
+export declare const FULLSCREEN_OVERLAY_ID = "mappedin-viewer-fullscreen-overlay";
+export declare const FullscreenOverlay: import("styled-components").IStyledComponent<"web", {
+    hidden?: boolean | undefined;
+    children?: import("react").ReactNode;
+    slot?: string | undefined;
+    style?: import("react").CSSProperties | undefined;
+    title?: string | undefined;
+    key?: import("react").Key | null | undefined;
+    className?: string | undefined;
+    id?: string | undefined;
+    prefix?: string | undefined;
+    role?: import("react").AriaRole | undefined;
+    nonce?: string | undefined;
+    tabIndex?: number | undefined;
+    defaultChecked?: boolean | undefined;
+    defaultValue?: string | number | readonly string[] | undefined;
+    suppressContentEditableWarning?: boolean | undefined;
+    suppressHydrationWarning?: boolean | undefined;
+    accessKey?: string | undefined;
+    autoFocus?: boolean | undefined;
+    contentEditable?: "inherit" | (boolean | "true" | "false") | undefined;
+    contextMenu?: string | undefined;
+    dir?: string | undefined;
+    draggable?: (boolean | "true" | "false") | undefined;
+    lang?: string | undefined;
+    placeholder?: string | undefined;
+    spellCheck?: (boolean | "true" | "false") | undefined;
+    translate?: "yes" | "no" | undefined;
+    radioGroup?: string | undefined;
+    about?: string | undefined;
+    content?: string | undefined;
+    datatype?: string | undefined;
+    inlist?: any;
+    property?: string | undefined;
+    rel?: string | undefined;
+    resource?: string | undefined;
+    rev?: string | undefined;
+    typeof?: string | undefined;
+    vocab?: string | undefined;
+    autoCapitalize?: string | undefined;
+    autoCorrect?: string | undefined;
+    autoSave?: string | undefined;
+    color?: string | undefined;
+    itemProp?: string | undefined;
+    itemScope?: boolean | undefined;
+    itemType?: string | undefined;
+    itemID?: string | undefined;
+    itemRef?: string | undefined;
+    results?: number | undefined;
+    security?: string | undefined;
+    unselectable?: "on" | "off" | undefined;
+    inputMode?: "search" | "text" | "url" | "none" | "tel" | "email" | "numeric" | "decimal" | undefined;
+    is?: string | undefined;
+    'aria-activedescendant'?: string | undefined;
+    'aria-atomic'?: (boolean | "true" | "false") | undefined;
+    'aria-autocomplete'?: "none" | "both" | "list" | "inline" | undefined;
+    'aria-braillelabel'?: string | undefined;
+    'aria-brailleroledescription'?: string | undefined;
+    'aria-busy'?: (boolean | "true" | "false") | undefined;
+    'aria-checked'?: boolean | "true" | "false" | "mixed" | undefined;
+    'aria-colcount'?: number | undefined;
+    'aria-colindex'?: number | undefined;
+    'aria-colindextext'?: string | undefined;
+    'aria-colspan'?: number | undefined;
+    'aria-controls'?: string | undefined;
+    'aria-current'?: boolean | "time" | "location" | "true" | "step" | "false" | "page" | "date" | undefined;
+    'aria-describedby'?: string | undefined;
+    'aria-description'?: string | undefined;
+    'aria-details'?: string | undefined;
+    'aria-disabled'?: (boolean | "true" | "false") | undefined;
+    'aria-dropeffect'?: "link" | "none" | "copy" | "execute" | "move" | "popup" | undefined;
+    'aria-errormessage'?: string | undefined;
+    'aria-expanded'?: (boolean | "true" | "false") | undefined;
+    'aria-flowto'?: string | undefined;
+    'aria-grabbed'?: (boolean | "true" | "false") | undefined;
+    'aria-haspopup'?: boolean | "dialog" | "menu" | "listbox" | "grid" | "tree" | "true" | "false" | undefined;
+    'aria-hidden'?: (boolean | "true" | "false") | undefined;
+    'aria-invalid'?: boolean | "true" | "false" | "grammar" | "spelling" | undefined;
+    'aria-keyshortcuts'?: string | undefined;
+    'aria-label'?: string | undefined;
+    'aria-labelledby'?: string | undefined;
+    'aria-level'?: number | undefined;
+    'aria-live'?: "off" | "assertive" | "polite" | undefined;
+    'aria-modal'?: (boolean | "true" | "false") | undefined;
+    'aria-multiline'?: (boolean | "true" | "false") | undefined;
+    'aria-multiselectable'?: (boolean | "true" | "false") | undefined;
+    'aria-orientation'?: "horizontal" | "vertical" | undefined;
+    'aria-owns'?: string | undefined;
+    'aria-placeholder'?: string | undefined;
+    'aria-posinset'?: number | undefined;
+    'aria-pressed'?: boolean | "true" | "false" | "mixed" | undefined;
+    'aria-readonly'?: (boolean | "true" | "false") | undefined;
+    'aria-relevant'?: "text" | "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text additions" | "text removals" | undefined;
+    'aria-required'?: (boolean | "true" | "false") | undefined;
+    'aria-roledescription'?: string | undefined;
+    'aria-rowcount'?: number | undefined;
+    'aria-rowindex'?: number | undefined;
+    'aria-rowindextext'?: string | undefined;
+    'aria-rowspan'?: number | undefined;
+    'aria-selected'?: (boolean | "true" | "false") | undefined;
+    'aria-setsize'?: number | undefined;
+    'aria-sort'?: "none" | "ascending" | "descending" | "other" | undefined;
+    'aria-valuemax'?: number | undefined;
+    'aria-valuemin'?: number | undefined;
+    'aria-valuenow'?: number | undefined;
+    'aria-valuetext'?: string | undefined;
+    dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    } | undefined;
+    onCopy?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
+    onCopyCapture?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
+    onCut?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
+    onCutCapture?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
+    onPaste?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
+    onPasteCapture?: import("react").ClipboardEventHandler<HTMLDivElement> | undefined;
+    onCompositionEnd?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
+    onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
+    onCompositionStart?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
+    onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
+    onCompositionUpdate?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
+    onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLDivElement> | undefined;
+    onFocus?: import("react").FocusEventHandler<HTMLDivElement> | undefined;
+    onFocusCapture?: import("react").FocusEventHandler<HTMLDivElement> | undefined;
+    onBlur?: import("react").FocusEventHandler<HTMLDivElement> | undefined;
+    onBlurCapture?: import("react").FocusEventHandler<HTMLDivElement> | undefined;
+    onChange?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+    onChangeCapture?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+    onBeforeInput?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+    onBeforeInputCapture?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+    onInput?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+    onInputCapture?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+    onReset?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+    onResetCapture?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+    onSubmit?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+    onSubmitCapture?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+    onInvalid?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+    onInvalidCapture?: import("react").FormEventHandler<HTMLDivElement> | undefined;
+    onLoad?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onLoadCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onError?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onErrorCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onKeyDown?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
+    onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
+    onKeyPress?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
+    onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
+    onKeyUp?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
+    onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLDivElement> | undefined;
+    onAbort?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onAbortCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onCanPlay?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onCanPlayCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onCanPlayThrough?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onDurationChange?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onDurationChangeCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onEmptied?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onEmptiedCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onEncrypted?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onEncryptedCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onEnded?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onEndedCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onLoadedData?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onLoadedDataCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onLoadedMetadata?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onLoadStart?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onLoadStartCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onPause?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onPauseCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onPlay?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onPlayCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onPlaying?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onPlayingCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onProgress?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onProgressCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onRateChange?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onRateChangeCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onResize?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onResizeCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onSeeked?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onSeekedCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onSeeking?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onSeekingCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onStalled?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onStalledCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onSuspend?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onSuspendCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onTimeUpdate?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onVolumeChange?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onWaiting?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onWaitingCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onAuxClick?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onAuxClickCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onClick?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onClickCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onContextMenu?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onContextMenuCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onDoubleClick?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onDoubleClickCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onDrag?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragEnd?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragEndCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragEnter?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragEnterCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragExit?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragExitCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragLeave?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragLeaveCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragOver?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragOverCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragStart?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDragStartCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDrop?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onDropCapture?: import("react").DragEventHandler<HTMLDivElement> | undefined;
+    onMouseDown?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseDownCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseEnter?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseLeave?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseMove?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseMoveCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseOut?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseOutCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseOver?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseOverCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseUp?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onMouseUpCapture?: import("react").MouseEventHandler<HTMLDivElement> | undefined;
+    onSelect?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onSelectCapture?: import("react").ReactEventHandler<HTMLDivElement> | undefined;
+    onTouchCancel?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+    onTouchCancelCapture?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+    onTouchEnd?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+    onTouchEndCapture?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+    onTouchMove?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+    onTouchMoveCapture?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+    onTouchStart?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+    onTouchStartCapture?: import("react").TouchEventHandler<HTMLDivElement> | undefined;
+    onPointerDown?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerDownCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerMove?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerMoveCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerUp?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerUpCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerCancel?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerCancelCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerEnter?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerEnterCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerLeave?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerLeaveCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerOver?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerOverCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerOut?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onPointerOutCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onGotPointerCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onLostPointerCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLDivElement> | undefined;
+    onScroll?: import("react").UIEventHandler<HTMLDivElement> | undefined;
+    onScrollCapture?: import("react").UIEventHandler<HTMLDivElement> | undefined;
+    onWheel?: import("react").WheelEventHandler<HTMLDivElement> | undefined;
+    onWheelCapture?: import("react").WheelEventHandler<HTMLDivElement> | undefined;
+    onAnimationStart?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
+    onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
+    onAnimationEnd?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
+    onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
+    onAnimationIteration?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
+    onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLDivElement> | undefined;
+    onTransitionEnd?: import("react").TransitionEventHandler<HTMLDivElement> | undefined;
+    onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLDivElement> | undefined;
+    ref?: ((instance: HTMLDivElement | null) => void) | import("react").RefObject<HTMLDivElement> | null | undefined;
+}>;

package/dist/types/components/main/index.d.ts

@@ -1,7 +1,7 @@
-import SearchBar from '../search-bar';
-import Directions from '../directions';
 import { ComponentProps } from 'react';
 import { TCategory, TSearchResult } from '../../lib/types/search';
+import Directions from '../directions';
+import SearchBar from '../search-bar';
 type TMainUIProps = {
     onBlur?: () => void;
     query?: string;

package/dist/types/components/metadata-card/carousel.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+type TCarouselProps = {
+    imageURLs: string[];
+};
+export declare const Carousel: React.FC<TCarouselProps>;
+export {};

package/dist/types/components/metadata-card/details-section.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+type TDetailsSectionProps = {
+    name: string;
+    description?: string;
+    links?: {
+        url: string;
+        displayName: string;
+    }[];
+    collapsible?: boolean;
+};
+declare const DetailsSection: React.FC<TDetailsSectionProps>;
+export default DetailsSection;

package/dist/types/components/metadata-card/directions-button.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+declare const DirectionsButton: React.FC<{
+    onClick?: () => void;
+}>;
+export default DirectionsButton;

package/dist/types/components/metadata-card/index.d.ts

@@ -0,0 +1,12 @@
+import React, { ComponentProps } from 'react';
+import DetailsSection from './details-section';
+export type TMetadataCardProps = {
+    name: ComponentProps<typeof DetailsSection>['name'];
+    description?: ComponentProps<typeof DetailsSection>['description'];
+    links?: ComponentProps<typeof DetailsSection>['links'];
+    imageURLs?: string[];
+    onRequestClose?: () => void;
+    onDirectionsClick?: () => void;
+};
+declare const MetadataCard: React.FC<TMetadataCardProps>;
+export default MetadataCard;

package/dist/types/components/metadata-card/link-item.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+type TLinkItemProps = {
+    url: string;
+    displayName: string;
+};
+declare const LinkItem: React.FC<TLinkItemProps>;
+export default LinkItem;

package/dist/types/components/metadata-card/metadata-card.stories.d.ts

@@ -0,0 +1,7 @@
+import type { Story } from '@ladle/react';
+export declare const Default: Story;
+export declare const ImageNameAndDesc: Story;
+export declare const ImageDescAndLinks: Story;
+export declare const NameAndDesc: Story;
+export declare const ImageAndName: Story;
+export declare const NoHover: Story;

package/dist/types/components/metadata-card/nav-chevrons.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+type TNavChevronProps = {
+    size: number;
+    onNext: () => void;
+    onPrevious: () => void;
+};
+declare const NavChevrons: React.FC<TNavChevronProps>;
+export default NavChevrons;

package/dist/types/components/metadata-card/nav-pills.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+type TNavPillsProps = {
+    count: number;
+    size: number;
+    activeIndex: number;
+    onClick: (index: number) => void;
+};
+declare const NavPills: React.FC<TNavPillsProps>;
+export default NavPills;

package/dist/types/components/positioner/index.d.ts

@@ -49,7 +49,7 @@ declare const Positioner: import("styled-components").IStyledComponent<"web", {
     results?: number | undefined;
     security?: string | undefined;
     unselectable?: "on" | "off" | undefined;
-    inputMode?: "search" | "text" | "none" | "tel" | "url" | "email" | "numeric" | "decimal" | undefined;
+    inputMode?: "search" | "text" | "url" | "none" | "tel" | "email" | "numeric" | "decimal" | undefined;
     is?: string | undefined;
     children?: import("react").ReactNode;
     'aria-activedescendant'?: string | undefined;

package/dist/types/components/search-bar/index.d.ts

@@ -1,6 +1,6 @@
-import Input from '../input';
-import Button from '../button';
 import { ComponentProps } from 'react';
+import Button from '../button';
+import Input from '../input';
 type TSearchBarProps = {
     placeholder: string;
     value: string;

package/dist/types/components/search-results/index.d.ts

@@ -5,6 +5,7 @@ type TSearchResultsProps = {
     onResultClick?: (result: TSearchResult) => void;
     visible?: boolean;
     maxHeight?: number;
+    maxWidth?: number;
     fallbackTitle?: string;
     fallbackText?: string;
 };

package/dist/types/index.d.ts

@@ -1,4 +1,8 @@
+import ReactDOM from 'react-dom/client';
+import { TMetadataCardProps } from './components/metadata-card';
 import type { TStartViewerOptions, TStartViewerWithLocalDataOptions } from './lib/types/options';
+export { default as MetadataCard } from './components/metadata-card';
+export declare const showMetadataCard: (container: Element, props: TMetadataCardProps) => ReactDOM.Root;
 declare const start: (options: TStartViewerOptions) => void;
 export default start;
 export declare const startWithLocalData: (options: TStartViewerWithLocalDataOptions) => void;

package/dist/types/lib/hooks/use-app-data.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/lib/hooks/use-window.d.ts

@@ -1,14 +1,15 @@
-type TUseMobileProps = {
+type TUseWindowProps = {
     onResize?: ({ isMobile, width, height }: {
         isMobile: boolean;
         width: number;
         height: number;
     }) => void;
 };
-declare const useMobile: ({ onResize }?: TUseMobileProps) => {
+declare const useWindow: ({ onResize }?: TUseWindowProps) => {
     width: number;
     height: number;
     isMobile: boolean;
     orientation: "landscape" | "portrait";
+    fullscreenRoot: HTMLElement | null;
 };
-export default useMobile;
+export default useWindow;

package/dist/types/lib/sdk/index.d.ts

@@ -0,0 +1,11 @@
+import { MapData, Space, MapObject, PointOfInterest, Connection, Annotation, Coordinate, Door } from '@mappedin/maker-sdk';
+export declare const loadData: (mapId: string, url?: string) => Promise<MapData>;
+export declare const loadAnnotationAsset: (annotation: Annotation) => string | undefined;
+export declare const isOneOf: <T extends typeof Space | typeof PointOfInterest | typeof Connection | typeof MapObject | typeof Door | typeof Coordinate>(types: T[], object: object) => object is InstanceType<T>;
+export declare const PLACE_TYPES: (typeof Space | typeof PointOfInterest | typeof Connection | typeof MapObject | typeof Door | typeof Coordinate)[];
+export type PlaceType = (typeof PLACE_TYPES)[number];
+export type Place = InstanceType<PlaceType>;
+export declare const GEOMETRY_TYPES: (typeof Space | typeof MapObject)[];
+export type GeometryType = (typeof GEOMETRY_TYPES)[number];
+export type Geometry = InstanceType<GeometryType>;
+export * from '@mappedin/maker-sdk';

package/dist/types/lib/types/options.d.ts

@@ -1,9 +1,7 @@
-/// <reference types="@mappedin/mappedin-js" />
 import { TTheme } from 'lib/types/theme';
 import { DeepPartial } from './utils';
-import type { hydrateVenueMVF } from '@mappedin/mappedin-js/get-venue';
 import type { PostHog } from 'posthog-js';
-type ParsedMVF = Parameters<typeof hydrateVenueMVF>[0];
+import { ParsedMVF } from '@mappedin/mvf';
 export type TStartViewerCommonOptions = {
     root?: HTMLElement;
     baseUrl?: string;
@@ -22,4 +20,3 @@ export type TStartViewerWithLocalDataOptions = {
     format?: 'mvf' | 'json';
     posthog?: PostHog;
 } & TStartViewerCommonOptions;
-export {};

package/dist/types/lib/types/state.d.ts

@@ -2,3 +2,9 @@ export declare enum E_APP_STATE {
     START = "/",
     DIRECTIONS = "/directions"
 }
+export type TParams = {
+    location: string[];
+    departure: string[];
+    me: string;
+    embedded: string;
+};

package/dist/types/lib/types/theme.d.ts

@@ -5,11 +5,15 @@ export type TTheme = {
             neutral: string;
             success: string;
         };
-        background: string;
+        background: {
+            primary: string;
+            inverted: string;
+        };
         text: {
             primary: string;
             secondary: string;
             placeholder: string;
+            inverted: string;
         };
         map: {
             labels: {
@@ -41,6 +45,13 @@ export type TTheme = {
         large: number;
         xlarge: number;
     };
+    fontWeight: {
+        light: number;
+        normal: number;
+        medium: number;
+        semiBold: number;
+        bold: number;
+    };
     map: {
         initialTilt: number;
         initialRotation: number;

package/dist/types/{stores/map-store/controllers/markers.lib.d.ts → lib/utils/annotation-utils.d.ts}

@@ -1,2 +1,2 @@
-import { TFeatureFlags } from '../../feature-flag-store';
+import { TFeatureFlags } from '../../stores/feature-flag-store';
 export declare const shouldDisplayAnnotations: (flags: TFeatureFlags, orgId?: string) => boolean;

package/dist/types/lib/utils/data-utils.d.ts

@@ -1,14 +1,20 @@
-import type { MappedinLocation } from '@mappedin/mappedin-js';
-import { Connection } from '@mappedin/mvf';
-export declare const isWashroom: (location: MappedinLocation) => boolean;
-export declare const isPointOfInterest: (location: MappedinLocation) => boolean;
-export declare const isConnection: (feature: unknown) => feature is Connection;
-export declare const isConnectionLocation: (location: MappedinLocation) => boolean;
-export declare const INTERACTIVE_LOCATION_CATEGORIES: string[];
-export declare const isInteractiveLocation: (location: MappedinLocation) => boolean;
-export declare const isUnnamedConnection: (location: MappedinLocation) => boolean;
-/**
- * Unnamed connection spaces are given a name in the format of unnamed-connecton-{id}. Given
- * an unnamed connection space, this function returns the id of the connection spaces.
- */
-export declare const getUnnamedConnectionId: (location: MappedinLocation) => string | undefined;
+import { Place } from '../sdk';
+/**
+ * Whether the location can be assumed to be a washroom
+ */
+export declare const isWashroom: (place: Place) => boolean;
+/**
+ * Whether the location has any metadata other than name
+ * @returns
+ */
+export declare const hasMetaData: (place: Place) => boolean;
+export declare const getCategoryName: (place: Place) => string;
+/**
+ * For a location, return a name that is as specific as we can be.
+ */
+export declare const getDisplayNameForPlace: (place: Place) => string;
+/**
+ * For a list of locations, return a generic name that is as specific as
+ * we can be.
+ */
+export declare const getDisplayNameForPlaces: (places: Place[]) => string;

package/dist/types/lib/utils/data-utils.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/lib/utils/not-null.d.ts

@@ -0,0 +1 @@
+export declare const notNull: <T>(value: T | null | undefined) => value is T;

package/dist/types/stores/feature-flag-store/feature-flag-store.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/types/stores/map-store/controllers/camera.d.ts

@@ -1,7 +1,7 @@
 import type RootStore from '../../root-store';
 import type MapStore from '..';
-import { CAMERA_EVENT_PAYLOAD, E_CAMERA_EVENT, MapView, TCameraAnimationOptions } from '@mappedin/mappedin-js';
-export declare const ZOOM_FACTOR = 1.5;
+import { MapView, TCameraAnimationOptions, TEvents } from '../../../lib/sdk';
+export declare const ZOOM_FACTOR = 1.025;
 export declare const TILT_FACTOR = 0.025;
 export declare const CAMERA_ANIMATION_OPTIONS: TCameraAnimationOptions;
 declare class CameraController {
@@ -16,11 +16,10 @@ declare class CameraController {
         mapStore: MapStore;
     });
     private getPadding;
-    private updatePadding;
-    handleCameraChange({ zoom }: CAMERA_EVENT_PAYLOAD[E_CAMERA_EVENT.CHANGED]): void;
+    handleCameraChange(payload?: TEvents['camera-change']): void;
     handleUserInteractionStart(): void;
     handleUserInteractionEnd(): void;
-    focusOn(targets: Parameters<MapView['Camera']['focusOn']>[0], options?: Parameters<MapView['Camera']['focusOn']>[1]): Promise<void>;
+    focusOn(...[targets, options]: Parameters<MapView['Camera']['focusOn']>): Promise<void>;
     zoomIn(): Promise<void>;
     zoomOut(): Promise<void>;
     resetZoom(): Promise<void>;

package/dist/types/stores/map-store/controllers/camera.test.d.ts

@@ -1 +0,0 @@
-export {};