@cosmicds/vue-toolkit 0.3.0 → 0.4.0

package/dist/src/background.d.ts

@@ -1,6 +1,10 @@
+/** Class representing a background imageset for WorldWide Telescope */
 export declare class BackgroundImageset {
+    /** The outward-facing name to use for the imageset in a story */
     imagesetName: string;
+    /** The name of the imageset object inside WorldWide Telescope */
     displayName: string;
     constructor(displayName: string, imagesetName: string);
 }
+/** A default list of `BackgroundImagset` objects to use within data stories */
 export declare const skyBackgroundImagesets: BackgroundImageset[];

package/dist/src/components/CreditLogos.vue.d.ts

@@ -1,23 +1,28 @@
 declare const _default: import("vue").DefineComponent<{
-    visible: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
     logoSize: {
         default: string;
     };
+    extraLogos: {
+        default: () => never[];
+    };
+    defaultLogos: {
+        default: () => string[];
+    };
 }, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
 }>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
-    visible: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
     logoSize: {
         default: string;
     };
+    extraLogos: {
+        default: () => never[];
+    };
+    defaultLogos: {
+        default: () => string[];
+    };
 }>>, {
-    visible: boolean;
     logoSize: string;
+    extraLogos: never[];
+    defaultLogos: string[];
 }, {}>;
 export default _default;

package/dist/src/components/Gallery.vue.d.ts

@@ -67,10 +67,10 @@ declare const _default: import("vue").DefineComponent<{
     onDeselect?: ((...args: any[]) => any) | undefined;
     onListAllSelected?: ((...args: any[]) => any) | undefined;
 }, {
-    maxHeight: string;
+    columns: string;
     width: string;
+    maxHeight: string;
     title: string;
-    columns: string;
     selectedColor: string;
     singleSelect: boolean;
     highlightLastOnly: boolean;

package/dist/src/components/GeolocationButton.vue.d.ts

@@ -2,10 +2,6 @@ declare const _default: import("vue").DefineComponent<{
     color: {
         default: string;
     };
-    disabled: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
     size: {
         default: string;
     };
@@ -52,23 +48,16 @@ declare const _default: import("vue").DefineComponent<{
     falseIcon: {
         default: string;
     };
-    backgroundColor: {
-        default: string;
-    };
     showPermissions: {
         type: BooleanConstructor;
         default: boolean;
     };
 }, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
-}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("permission" | "geolocation" | "error")[], "permission" | "geolocation" | "error", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("error" | "geolocation" | "permission")[], "error" | "geolocation" | "permission", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     color: {
         default: string;
     };
-    disabled: {
-        type: BooleanConstructor;
-        default: boolean;
-    };
     size: {
         default: string;
     };
@@ -115,21 +104,18 @@ declare const _default: import("vue").DefineComponent<{
     falseIcon: {
         default: string;
     };
-    backgroundColor: {
-        default: string;
-    };
     showPermissions: {
         type: BooleanConstructor;
         default: boolean;
     };
 }>> & {
-    onPermission?: ((...args: any[]) => any) | undefined;
-    onGeolocation?: ((...args: any[]) => any) | undefined;
     onError?: ((...args: any[]) => any) | undefined;
+    onGeolocation?: ((...args: any[]) => any) | undefined;
+    onPermission?: ((...args: any[]) => any) | undefined;
 }, {
-    color: string;
-    disabled: boolean;
     size: string;
+    color: string;
+    label: string;
     density: string;
     elevation: string;
     hideButton: boolean;
@@ -139,10 +125,8 @@ declare const _default: import("vue").DefineComponent<{
     showProgressCircle: boolean;
     useTextButton: boolean;
     progressCircleSize: number;
-    label: string;
     trueIcon: string;
     falseIcon: string;
-    backgroundColor: string;
     showPermissions: boolean;
 }, {}>;
 export default _default;

package/dist/src/components/IconButton.vue.d.ts

@@ -10,12 +10,11 @@ declare const _default: import("vue").DefineComponent<{
     focusColor: {
         default: string;
     };
-    backgroundColor: {
+    activeColor: {
         default: string;
     };
-    boxShadow: {
-        type: BooleanConstructor;
-        default: boolean;
+    backgroundColor: {
+        default: string;
     };
     border: {
         type: BooleanConstructor;
@@ -67,12 +66,11 @@ declare const _default: import("vue").DefineComponent<{
     focusColor: {
         default: string;
     };
-    backgroundColor: {
+    activeColor: {
         default: string;
     };
-    boxShadow: {
-        type: BooleanConstructor;
-        default: boolean;
+    backgroundColor: {
+        default: string;
     };
     border: {
         type: BooleanConstructor;
@@ -114,20 +112,20 @@ declare const _default: import("vue").DefineComponent<{
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
     onActivate?: ((...args: any[]) => any) | undefined;
 }, {
+    border: boolean;
     color: string;
     backgroundColor: string;
-    border: boolean;
     modelValue: boolean;
     focusColor: string;
-    boxShadow: boolean;
     longPressTimeMs: number;
     tooltipLocation: string;
     tooltipOnClick: boolean;
     tooltipOnFocus: boolean;
     tooltipOnHover: boolean;
-    tooltipOffset: number;
     showTooltip: boolean;
     faSize: string;
     mdSize: string;
+    activeColor: string;
+    tooltipOffset: number;
 }, {}>;
 export default _default;

package/dist/src/components/LocationSelector.vue.d.ts

@@ -56,7 +56,7 @@ declare const _default: import("vue").DefineComponent<{
     };
 }, (_ctx: any, _cache: any) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
     [key: string]: any;
-}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("error" | "place" | "update:modelValue" | "mapReady")[], "error" | "place" | "update:modelValue" | "mapReady", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+}>, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("place" | "error" | "update:modelValue" | "mapReady")[], "place" | "error" | "update:modelValue" | "mapReady", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     activatorColor: {
         default: string;
     };
@@ -110,9 +110,9 @@ declare const _default: import("vue").DefineComponent<{
         default: () => never[];
     };
 }>> & {
-    onError?: ((...args: any[]) => any) | undefined;
     "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
     onPlace?: ((...args: any[]) => any) | undefined;
+    onError?: ((...args: any[]) => any) | undefined;
     onMapReady?: ((...args: any[]) => any) | undefined;
 }, {
     modelValue: {
@@ -121,19 +121,19 @@ declare const _default: import("vue").DefineComponent<{
     };
     activatorColor: string;
     detectLocation: boolean;
+    placeSelectable: boolean;
+    selectable: boolean;
+    selectionEvent: string;
+    worldRadii: boolean;
     mapOptions: LeafletMapOptions;
     places: never[];
     placeCircleOptions: L.CircleMarkerOptions;
-    placeSelectable: boolean;
-    selectable: boolean;
     selectedCircleOptions: {
         color: string;
         fillColor: string;
         fillOpacity: number;
         radius: number;
     };
-    selectionEvent: string;
-    worldRadii: boolean;
     geoJsonFiles: never[];
     layers: never[];
 }, {}>;

package/dist/src/components/WwtHud.vue.d.ts

@@ -53,17 +53,17 @@ declare const _default: import("vue").DefineComponent<{
     };
     store: {};
 }>>, {
-    backgroundColor: string;
     location: {
         top: string;
         left: string;
     };
+    backgroundColor: string;
+    fontSize: string;
+    textShadow: string;
     offsetCenter: {
         x: number;
         y: number;
     };
     otherVariables: {};
-    fontSize: string;
-    textShadow: string;
 }, {}>;
 export default _default;

package/dist/src/composables.d.ts

@@ -1,17 +1,25 @@
 import { Ref } from "vue";
+/**
+  * A composable that encapsulates fullscreen behavior.
+  * @returns A reactive variable indicating whether or not fullscreen mode is active
+  */
 export declare function useFullscreen(): Ref<boolean>;
+/** Interface describing the shape of a browser window */
 export interface WindowShape {
     width: number;
     height: number;
 }
+/** A default `WindowShape` to use */
 export declare const defaultWindowShape: {
     width: number;
     height: number;
 };
-export declare function useWindowShape(): {
-    windowShape: Ref<{
-        width: number;
-        height: number;
-    }>;
-    resizeObserver: ResizeObserver;
-};
+/**
+  * A composable that encapsulates a changing window shape.
+  *
+  * @returns A reactive variable describing the current window shape.
+  */
+export declare function useWindowShape(): Ref<{
+    width: number;
+    height: number;
+}>;

package/dist/src/geolocation.d.ts

@@ -1,5 +1,11 @@
 import { Position } from "@capacitor/geolocation";
 export type PositionCoords = Position['coords'];
+/**
+  * A composable that encapsulates the current state of the browser
+  * geolocation position and permission status.
+  * @param onStartup - Whether or not to query the user's geolocation on startup.
+  * @returns Reactive state describing the geolocation
+  */
 export declare function useGeolocation(onStartup?: boolean): {
     geolocation: import("vue").Ref<{
         latitude: number;

package/dist/src/index.d.ts

@@ -1,7 +1,7 @@
 import { BackgroundImageset, skyBackgroundImagesets } from "./background";
 import { useFullscreen, useWindowShape, WindowShape } from "./composables";
 import { PositionCoords, useGeolocation } from "./geolocation";
-import { KeyboardControlSettings } from "./keyboard";
+import { KeyPressInfo, KeyboardControlSettings } from "./keyboard";
 import { useWWTKeyboardControls } from "./wwt-utils";
 import IconButton from "./components/IconButton.vue";
 import LocationSelector from "./components/LocationSelector.vue";
@@ -10,6 +10,6 @@ import CreditLogos from "./components/CreditLogos.vue";
 import GeolocationButton from "./components/GeolocationButton.vue";
 import WwtHud from "./components/WwtHud.vue";
 import Gallery from "./components/Gallery.vue";
-export { BackgroundImageset, KeyboardControlSettings, Gallery, IconButton, LocationSelector, skyBackgroundImagesets, useFullscreen, useWindowShape, WindowShape, FundingAcknowledgement, CreditLogos, GeolocationButton, WwtHud, PositionCoords, useGeolocation, useWWTKeyboardControls, };
+export { BackgroundImageset, KeyPressInfo, KeyboardControlSettings, Gallery, IconButton, LocationSelector, skyBackgroundImagesets, useFullscreen, useWindowShape, WindowShape, FundingAcknowledgement, CreditLogos, GeolocationButton, WwtHud, PositionCoords, useGeolocation, useWWTKeyboardControls, };
 export * from "./types";
 export * from "./utils";

package/dist/src/keyboard.d.ts

@@ -1,24 +1,52 @@
-declare class KeyPressInfo {
+/** Class representing a key press */
+export declare class KeyPressInfo {
+    /** The code of the key that was pressed */
     code: string;
+    /** Whether the control modifier was pressed */
     ctrl: boolean;
+    /** Whether the alt modifier was pressed */
     alt: boolean;
+    /** Whether the shift modifier was pressed */
     shift: boolean;
+    /** Whether the meta modifier was pressed */
     meta: boolean;
+    /**
+      * Create an instance of key press information
+      * @param code The key code describing the keypress
+      * @param modifiers An object of boolean values describing which modifier keys were pressed down
+      */
     constructor(code: string, modifiers?: {
         ctrl?: boolean;
         alt?: boolean;
         shift?: boolean;
         meta?: boolean;
     });
+    /**
+      * Determine whether a keyboard event matches this key press information
+      * @param event - The keyboard event to test
+      * @returns Whether or not the given event matches
+      */
     matches(event: KeyboardEvent): boolean;
 }
+/** Type describing the possible WWT actions */
+type ActionType = KeyboardControlSettings["actionTypes"][number];
+/**
+  * Class describing keyboard control settings for WorldWide Telescope actions
+  */
 export declare class KeyboardControlSettings {
+    /** A list of key presses that should result in zooming in */
     zoomIn: KeyPressInfo[];
+    /** A list of key presses that should result in zooming out */
     zoomOut: KeyPressInfo[];
+    /** A list of key presses that should result in moving the view up */
     moveUp: KeyPressInfo[];
+    /** A list of key presses that should result in moving the view down */
     moveDown: KeyPressInfo[];
+    /** A list of key presses that should result in moving the view left */
     moveLeft: KeyPressInfo[];
+    /** A list of key presses that should result in moving the view right */
     moveRight: KeyPressInfo[];
+    /** A value describing how much to move on a movement press. Larger means more movement. */
     moveAmount: number;
     constructor({ zoomIn, zoomOut, moveUp, moveLeft, moveDown, moveRight, moveAmount }: {
         zoomIn?: KeyPressInfo[] | undefined;
@@ -30,6 +58,11 @@ export declare class KeyboardControlSettings {
         moveAmount?: number | undefined;
     });
     readonly actionTypes: readonly ["zoomIn", "zoomOut", "moveUp", "moveDown", "moveLeft", "moveRight"];
-    makeListener(actionName: KeyboardControlSettings["actionTypes"][number], action: () => void): (event: KeyboardEvent) => void;
+    /** Make a listener for a given WWT action
+      * @param actionName - The WWT action to make a listener for
+      * @param action - Function to execute when the given WWT action occurs
+      * @returns The key event listener for the desired behavior
+      */
+    makeListener(actionName: ActionType, action: () => void): (event: KeyboardEvent) => void;
 }
 export {};

package/dist/src/mapbox.d.ts

@@ -1,3 +1,4 @@
+/** Interface describing a MapBox content item */
 export interface MapBoxContextItem {
     id: string;
     mapbox_id: string;
@@ -15,32 +16,83 @@ export interface MapBoxFeature {
     center: [number, number];
     context: MapBoxContextItem[];
 }
+/** Interface describing a MapBox feature collection, which is a GeoJSON object */
 export interface MapBoxFeatureCollection {
     type: "FeatureCollection";
+    /** The list of features in the collection */
     features: MapBoxFeature[];
 }
+/** Union type describing the feature types available in MapBox */
 export type MapBoxFeatureType = "country" | "region" | "postcode" | "district" | "place" | "locality" | "neighborhood" | "street" | "address";
+/** Union type describing the worldviews available in MapBox */
 export type MapBoxWorldviewType = "ar" | "cn" | "in" | "jp" | "ma" | "ru" | "tr" | "us";
+/** Interface describing options common to both forward and reverse MapBox geocoding */
 interface BaseMapBoxGeocodingOptions {
-    permanent?: boolean;
+    /** The language to use for the results, as an IEFT language tag */
     language?: string;
+    /** The number of results to return. Default is 5 */
     limit?: number;
+    /** Countries to include in the results. If a list is given, any result outside of these countries is omitted
+      * Specify countries using ISO 3166-1 alpha-2 country codes: https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
+      */
     countries?: string[];
+    /** The result types to include */
     types?: MapBoxFeatureType[];
+    /** The access token for MapBox. Required */
     access_token: string;
 }
+/** Interface describing options for forward geocoding */
 interface MapBoxForwardGeocodingOptions extends BaseMapBoxGeocodingOptions {
+    /** Whether to return autocomplete results. MapBox default is true */
     autocomplete?: boolean;
-    bbox?: number;
-    format?: "geojson" | "v5";
+    /** A bounding box for results. Should be a string of the form "minLon,minLat,maxLon,maxLat" */
+    bbox?: string;
+    /** Whether MapBox should try approximate, as well as exact, matching. MapBox default is true */
+    fuzzyMatch?: boolean;
+    /** If specified, results are biased to favor results closer to this location. Should be a string of the form "longitude, latitude" */
     proximity?: string;
 }
+/** Interface describing options for reverse geocoding */
 interface MapBoxReverseGeocodingOptions extends BaseMapBoxGeocodingOptions {
+    /** The worldview to use for search results. MapBox default is "us" */
     worldview?: MapBoxWorldviewType[];
 }
+/** Find the best feature from a collection of MapBox features.
+  * We look for feature place types in the order: 'place', 'postcode', 'region', 'country'
+  * @param collection The collection of items to search
+  * @param relevantTypes The set of feature place types to consider. If not specified, we use the four types mentioned above
+  * @returns The "best" feature, as described above
+  */
 export declare function findBestFeature(collection: MapBoxFeatureCollection, relevantTypes?: MapBoxFeatureType[]): MapBoxFeature | null;
+/**
+  * Create text describing a MapBox feature, based on the MapBox items inside of the feature's context
+  * @param feature The MapBox feature
+  * @param relevantTypes The item types inside the feature's context that we want to consider when creating the string. If not specified, we use 'place', 'postcode', 'region', and 'country'
+  * @returns A string describing the feature
+  */
 export declare function textForMapboxFeature(feature: MapBoxFeature, relevantTypes?: MapBoxFeatureType[]): string;
+/**
+  * Return text describing the "best" feature in a MapBox collection.
+  * See @link{findBestFeature} for a description of how a feature is chosen
+  * @param results The feature collection to use
+  * @param relevantTypes The item types inside the best feature's context that we want to consider when creating the string. If not specified, we use 'place', 'postcode', 'region', and 'country'
+  */
 export declare function textForMapboxResults(results: MapBoxFeatureCollection, relevantTypes?: MapBoxFeatureType[]): string;
+/**
+  * Obtain text describing a given longitude and latitude based on a MapBox reverse geocoding query
+  * @param longitudeDeg The longitude of the location, in degrees
+  * @param latitudeDeg The latitude of the location, in degrees
+  * @param options Options for the MapBox reverse geocoding
+  * @returns A promise that resolves to the string describing the given coordinates
+  */
 export declare function textForLocation(longitudeDeg: number, latitudeDeg: number, options: MapBoxReverseGeocodingOptions): Promise<string>;
+/**
+  * Obtain a collection of MapBox items obtained from performing a forward geocoding query for a particular search string.
+  * Note that the number of items returned is set by the `limit` field in your options.
+  * If `limit` is not specified, the MapBox default is 5
+  * @param searchText The search string
+  * @param options Options for the MapBox forward geocoding
+  * @returns A promise that resolves to the found collection of MapBox items
+  */
 export declare function geocodingInfoForSearch(searchText: string, options: MapBoxForwardGeocodingOptions): Promise<MapBoxFeatureCollection>;
 export {};

package/dist/src/stories/CreditLogos.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryObj } from "@storybook/vue3";
+import { CreditLogos } from "..";
+declare const meta: Meta<typeof CreditLogos>;
+export default meta;
+type Story = StoryObj<typeof CreditLogos>;
+export declare const Primary: Story;

package/dist/src/stories/FundingAcknowledgement.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryObj } from "@storybook/vue3";
+import { FundingAcknowledgement } from "..";
+declare const meta: Meta<typeof FundingAcknowledgement>;
+export default meta;
+type Story = StoryObj<typeof FundingAcknowledgement>;
+export declare const Primary: Story;

package/dist/src/stories/Gallery.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryObj } from "@storybook/vue3";
+import { Gallery } from "..";
+declare const meta: Meta<typeof Gallery>;
+export default meta;
+type Story = StoryObj<typeof Gallery>;
+export declare const Primary: Story;

package/dist/src/stories/IconButton.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryObj } from "@storybook/vue3";
+import { IconButton } from "..";
+declare const meta: Meta<typeof IconButton>;
+export default meta;
+type Story = StoryObj<typeof IconButton>;
+export declare const Primary: Story;

package/dist/src/stories/LocationSelector.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryObj } from "@storybook/vue3";
+import { LocationSelector } from "..";
+declare const meta: Meta<typeof LocationSelector>;
+export default meta;
+type Story = StoryObj<typeof LocationSelector>;
+export declare const Primary: Story;

package/dist/src/stories/WwtHud.stories.d.ts

@@ -0,0 +1,6 @@
+import { Meta, StoryObj } from "@storybook/vue3";
+import { WwtHud } from "..";
+declare const meta: Meta<typeof WwtHud>;
+export default meta;
+type Story = StoryObj<typeof WwtHud>;
+export declare const Primary: Story;