webamp 1.4.3-beta.5 → 2.0.0

package/built/types/js/reducers/equalizer.d.ts

@@ -0,0 +1,10 @@
+import { Slider, Action } from "./../types";
+import { EqualizerSerializedStateV1 } from "../serializedStates/v1Types";
+export interface EqualizerState {
+    on: boolean;
+    auto: boolean;
+    sliders: Record<Slider, number>;
+}
+declare const equalizer: (state: EqualizerState | undefined, action: Action) => EqualizerState;
+export declare function getSerializedState(state: EqualizerState): EqualizerSerializedStateV1;
+export default equalizer;

package/built/types/js/reducers/index.d.ts

@@ -0,0 +1,4 @@
+import { AppState, Action } from "../types";
+import { Reducer } from "redux";
+declare const reducer: Reducer<AppState, Action, never>;
+export default reducer;

package/built/types/js/reducers/media.d.ts

@@ -0,0 +1,14 @@
+import { Action, MediaStatus, TimeMode } from "../types";
+import { MediaSerializedStateV1 } from "../serializedStates/v1Types";
+export interface MediaState {
+    timeMode: TimeMode;
+    timeElapsed: number;
+    volume: number;
+    balance: number;
+    shuffle: boolean;
+    repeat: boolean;
+    status: MediaStatus;
+}
+declare const media: (state: MediaState | undefined, action: Action) => MediaState;
+export declare function getSerializedState(state: MediaState): MediaSerializedStateV1;
+export default media;

package/built/types/js/reducers/milkdrop.d.ts

@@ -0,0 +1,15 @@
+import { Action, StatePreset, TransitionType, MilkdropMessage } from "../types";
+export interface MilkdropState {
+    display: "WINDOW" | "DESKTOP" | "FULLSCREEN";
+    overlay: boolean;
+    presetHistory: number[];
+    presets: StatePreset[];
+    currentPresetIndex: number | null;
+    butterchurn: any;
+    transitionType: TransitionType;
+    randomize: boolean;
+    cycling: boolean;
+    message: MilkdropMessage | null;
+}
+export declare const milkdrop: (state: MilkdropState | undefined, action: Action) => MilkdropState;
+export default milkdrop;

package/built/types/js/reducers/network.d.ts

@@ -0,0 +1,6 @@
+import { Action } from "../types";
+export interface NetworkState {
+    connected: boolean;
+}
+declare const network: (state: NetworkState | undefined, action: Action) => NetworkState;
+export default network;

package/built/types/js/reducers/playlist.d.ts

@@ -0,0 +1,9 @@
+import { Action } from "../types";
+export interface PlaylistState {
+    trackOrder: number[];
+    lastSelectedIndex: number | null;
+    currentTrack: number | null;
+    selectedTracks: Set<number>;
+}
+declare const playlist: (state: PlaylistState | undefined, action: Action) => PlaylistState;
+export default playlist;

package/built/types/js/reducers/settings.d.ts

@@ -0,0 +1,6 @@
+import { Action, Skin } from "../types";
+export interface SettingsState {
+    availableSkins: Array<Skin>;
+}
+declare const settings: (state: SettingsState | undefined, action: Action) => SettingsState;
+export default settings;

package/built/types/js/reducers/tracks.d.ts

@@ -0,0 +1,7 @@
+import { PlaylistTrack, Action } from "../types";
+export interface TracksState {
+    [id: string]: PlaylistTrack;
+}
+declare const tracks: (state: TracksState | undefined, action: Action) => TracksState;
+export default tracks;
+export declare const getTrackDisplayName: (state: TracksState, id?: number | null) => string | null;

package/built/types/js/reducers/tracks.test.d.ts

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

package/built/types/js/reducers/userInput.d.ts

@@ -0,0 +1,9 @@
+import { Action, Slider } from "../types";
+export interface UserInputState {
+    focus: string | null;
+    bandFocused: Slider | null;
+    scrubPosition: number;
+    userMessage: string | null;
+}
+export declare const userInput: (state: UserInputState | undefined, action: Action) => UserInputState;
+export default userInput;

package/built/types/js/reducers/windows.d.ts

@@ -0,0 +1,34 @@
+import { Action, WindowId, Box, Point } from "../types";
+import { WindowsSerializedStateV1 } from "../serializedStates/v1Types";
+export type WindowPositions = {
+    [windowId: string]: Point;
+};
+export interface WebampWindow {
+    title: string;
+    size: [number, number];
+    open: boolean;
+    shade?: boolean;
+    canResize: boolean;
+    canShade: boolean;
+    canDouble: boolean;
+    hotkey?: string;
+    position: Point;
+}
+export interface WindowInfo extends Box {
+    key: WindowId;
+}
+export interface WindowsState {
+    focused: WindowId | null;
+    genWindows: {
+        [name: string]: WebampWindow;
+    };
+    browserWindowSize: {
+        height: number;
+        width: number;
+    };
+    positionsAreRelative: boolean;
+    windowOrder: WindowId[];
+}
+declare const windows: (state: WindowsState | undefined, action: Action) => WindowsState;
+export declare function getSerializedState(state: WindowsState): WindowsSerializedStateV1;
+export default windows;

package/built/types/js/regionParser.d.ts

@@ -0,0 +1,6 @@
+export declare function pointPairs(arr: string[]): string[];
+type RegionData = {
+    [section: string]: string[];
+};
+export default function regionParser(regionStr: string): RegionData;
+export {};

package/built/types/js/resizeUtils.d.ts

@@ -0,0 +1,23 @@
+import { WindowInfo } from "./types";
+interface PositionDiff {
+    [key: string]: {
+        x: number;
+        y: number;
+    };
+}
+export interface SizeDiff {
+    [key: string]: {
+        width: number;
+        height: number;
+    };
+}
+export declare function getPositionDiff(graph: Graph, sizeDiff: SizeDiff): PositionDiff;
+interface Edges {
+    below?: string;
+    right?: string;
+}
+export interface Graph {
+    [id: string]: Edges;
+}
+export declare function generateGraph(windows: WindowInfo[]): Graph;
+export {};

package/built/types/js/resizeUtils.test.d.ts

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

package/built/types/js/selectors.d.ts

@@ -0,0 +1,184 @@
+import { AppState, PlaylistTrack, WebampWindow, WindowId, LoadedURLTrack, PlaylistStyle, TransitionType, MediaStatus, TimeMode, SkinImages, Cursors, SkinRegion, GenLetterWidths, MilkdropMessage, DummyVizData } from "./types";
+import * as fromTracks from "./reducers/tracks";
+import * as fromWindows from "./reducers/windows";
+import { SerializedStateV1 } from "./serializedStates/v1Types";
+export declare const getSliders: (state: AppState) => Record<import("./types").Slider, number>;
+export declare const getEqfData: import("reselect").OutputSelector<AppState, {
+    presets: {
+        [key: string]: string | number;
+    }[];
+    type: string;
+}, (res: Record<import("./types").Slider, number>) => {
+    presets: {
+        [key: string]: string | number;
+    }[];
+    type: string;
+}>;
+export declare const getTracks: (state: AppState) => fromTracks.TracksState;
+export declare const getTrackUrl: (state: AppState) => (id: number) => string | null;
+export declare const getTrackOrder: (state: AppState) => number[];
+export declare const getTrackCount: import("reselect").OutputSelector<AppState, number, (res: number[]) => number>;
+export declare const getOrderedTracks: import("reselect").OutputSelector<AppState, number[], (res1: fromTracks.TracksState, res2: number[]) => number[]>;
+export declare const getUserTracks: import("reselect").OutputSelector<AppState, {
+    url: string;
+    metaData: {
+        artist: string;
+        title: string;
+        album: string | undefined;
+        albumArtUrl: string;
+    };
+}[], (res1: fromTracks.TracksState, res2: number[]) => {
+    url: string;
+    metaData: {
+        artist: string;
+        title: string;
+        album: string | undefined;
+        albumArtUrl: string;
+    };
+}[]>;
+export declare const getSelectedTrackIds: (state: AppState) => Set<number>;
+export declare const getSelectedTrackObjects: import("reselect").OutputSelector<AppState, PlaylistTrack[], (res1: PlaylistTrack[], res2: Set<number>) => PlaylistTrack[]>;
+export declare const getRunningTimeMessage: import("reselect").OutputSelector<AppState, string, (res1: number, res2: number) => string>;
+export declare const getCurrentTrackIndex: (state: AppState) => number;
+export declare const getCurrentTrackNumber: import("reselect").OutputSelector<AppState, number, (res: number) => number>;
+export declare const getCurrentTrackId: (state: AppState) => number | null;
+export declare const getRandomTrackId: (state: AppState) => number | null;
+export declare const getNextTrackId: (state: AppState, n?: number) => number | null;
+export declare const getGenWindows: (state: AppState) => {
+    [name: string]: fromWindows.WebampWindow;
+};
+export declare const getWindowOpen: import("reselect").OutputSelector<AppState, (windowId: WindowId) => boolean, (res: {
+    [name: string]: fromWindows.WebampWindow;
+}) => (windowId: WindowId) => boolean>;
+export declare const getWindowHidden: import("reselect").OutputSelector<AppState, (windowId: WindowId) => boolean, (res: boolean) => (windowId: WindowId) => boolean>;
+export declare const getWindowShade: import("reselect").OutputSelector<AppState, (windowId: WindowId) => boolean | undefined, (res: {
+    [name: string]: fromWindows.WebampWindow;
+}) => (windowId: WindowId) => boolean | undefined>;
+export declare const getWindowSize: import("reselect").OutputSelector<AppState, (windowId: WindowId) => [number, number], (res: {
+    [name: string]: fromWindows.WebampWindow;
+}) => (windowId: WindowId) => [number, number]>;
+export declare const getWindowPositions: import("reselect").OutputSelector<AppState, fromWindows.WindowPositions, (res: {
+    [name: string]: fromWindows.WebampWindow;
+}) => fromWindows.WindowPositions>;
+export declare const getNumberOfVisibleTracks: import("reselect").OutputSelector<AppState, number, (res: (windowId: WindowId) => [number, number]) => number>;
+export declare const getOverflowTrackCount: import("reselect").OutputSelector<AppState, number, (res1: number, res2: number) => number>;
+export declare const getPlaylistScrollPosition: import("reselect").OutputSelector<AppState, number, (res1: number, res2: number) => number>;
+export declare const getScrollOffset: import("reselect").OutputSelector<AppState, number, (res1: number, res2: number, res3: number) => number>;
+export declare const getVisibleTrackIds: import("reselect").OutputSelector<AppState, number[], (res1: number, res2: number[], res3: number) => number[]>;
+export declare function getAllTracksAreVisible(state: AppState): boolean;
+export declare const getTrackIsVisibleFunction: import("reselect").OutputSelector<AppState, (id: number) => boolean, (res: number[]) => (id: number) => boolean>;
+export declare const getVisibleTracks: import("reselect").OutputSelector<AppState, PlaylistTrack[], (res1: number[], res2: fromTracks.TracksState) => PlaylistTrack[]>;
+export declare const getPlaylist: (state: AppState) => import("./reducers/playlist").PlaylistState;
+export declare const getDuration: (state: AppState) => number | null;
+export declare const getTrackDisplayName: import("reselect").OutputSelector<AppState, (trackId: number | null) => string | null, (res: fromTracks.TracksState) => (trackId: number | null) => string | null>;
+export declare const getCurrentTrackDisplayName: import("reselect").OutputSelector<AppState, string | null, (res1: number | null, res2: (trackId: number | null) => string | null) => string | null>;
+export declare const getMediaStatus: (state: AppState) => MediaStatus;
+export declare const getMediaIsPlaying: (state: AppState) => boolean;
+export declare const getCurrentTrack: import("reselect").OutputSelector<AppState, PlaylistTrack | null, (res1: number | null, res2: fromTracks.TracksState) => PlaylistTrack | null>;
+export declare const getCurrentlyPlayingTrackIdIfLoaded: import("reselect").OutputSelector<AppState, number | null, (res1: boolean, res2: PlaylistTrack | null) => number | null>;
+export declare const getCurrentTrackInfo: import("reselect").OutputSelector<AppState, LoadedURLTrack | null, (res: PlaylistTrack | null) => LoadedURLTrack | null>;
+export declare const getMinimalMediaText: import("reselect").OutputSelector<AppState, string | null, (res1: number, res2: string | null) => string | null>;
+export declare const getMediaText: import("reselect").OutputSelector<AppState, string | null, (res1: string | null, res2: number | null) => string | null>;
+export declare const getNumberOfTracks: (state: AppState) => number;
+export declare const getPlaylistURL: import("reselect").OutputSelector<AppState, string, (res1: number, res2: number, res3: number[], res4: fromTracks.TracksState, res5: (trackId: number | null) => string | null) => string>;
+export declare function getFocusedWindow(state: AppState): WindowId | null;
+export declare function getWindowPosition(state: AppState): (windowId: WindowId) => import("./types").Point;
+export declare function getPositionsAreRelative(state: AppState): boolean;
+export declare function getDoubled(state: AppState): boolean;
+export declare function getLlamaMode(state: AppState): boolean;
+export declare function getZIndex(state: AppState): number;
+export declare const getWindowSizes: import("reselect").OutputSelector<AppState, {
+    [key: string]: {
+        height: number;
+        width: number;
+    };
+}, (res1: {
+    [name: string]: fromWindows.WebampWindow;
+}, res2: boolean) => {
+    [key: string]: {
+        height: number;
+        width: number;
+    };
+}>;
+export declare const getWindowPixelSize: import("reselect").OutputSelector<AppState, (windowId: WindowId) => {
+    height: number;
+    width: number;
+}, (res: {
+    [key: string]: {
+        height: number;
+        width: number;
+    };
+}) => (windowId: WindowId) => {
+    height: number;
+    width: number;
+}>;
+export declare const getNormalizedWindowOrder: import("reselect").OutputSelector<AppState, WindowId[], (res1: WindowId[], res2: {
+    [name: string]: fromWindows.WebampWindow;
+}) => WindowId[]>;
+export declare const getWindowsInfo: import("reselect").OutputSelector<AppState, fromWindows.WindowInfo[], (res1: {
+    [key: string]: {
+        height: number;
+        width: number;
+    };
+}, res2: fromWindows.WindowPositions, res3: WindowId[]) => fromWindows.WindowInfo[]>;
+export declare const getWindowGraph: import("reselect").OutputSelector<AppState, import("./resizeUtils").Graph, (res: fromWindows.WindowInfo[]) => import("./resizeUtils").Graph>;
+export declare function getSkinColors(state: AppState): string[];
+export declare const getSkinPlaylistStyle: (state: AppState) => PlaylistStyle;
+export declare const getVisualizerStyle: (state: AppState) => string;
+export declare const getVolume: (state: AppState) => number;
+export declare const getBalance: (state: AppState) => number;
+export declare const getShuffle: (state: AppState) => boolean;
+export declare const getRepeat: (state: AppState) => boolean;
+export declare const getChannels: import("reselect").OutputSelector<AppState, number | null, (res: PlaylistTrack | null) => number | null>;
+export declare const getTimeElapsed: (state: AppState) => number;
+export declare function getSerlializedState(state: AppState): SerializedStateV1;
+export declare function getEqualizerEnabled(state: AppState): boolean;
+export declare function getEqualizerAuto(state: AppState): boolean;
+export declare function getBrowserWindowSize(state: AppState): {
+    height: number;
+    width: number;
+};
+export declare const getOpenWindows: import("reselect").OutputSelector<AppState, {
+    [key: string]: fromWindows.WebampWindow;
+}, (res: {
+    [name: string]: fromWindows.WebampWindow;
+}) => {
+    [key: string]: fromWindows.WebampWindow;
+}>;
+export declare const getStackedLayoutPositions: import("reselect").OutputSelector<AppState, fromWindows.WindowPositions, (res1: {
+    [key: string]: fromWindows.WebampWindow;
+}, res2: boolean) => fromWindows.WindowPositions>;
+export declare const getUserInputFocus: (state: AppState) => string | null;
+export declare const getUserInputScrubPosition: (state: AppState) => number;
+export declare const getMarqueeText: (state: AppState) => string;
+export declare const getKbps: import("reselect").OutputSelector<AppState, string | null, (res: PlaylistTrack | null) => string | null>;
+export declare const getKhz: import("reselect").OutputSelector<AppState, string | null, (res: PlaylistTrack | null) => string | null>;
+export declare function getMilkdropMessage(state: AppState): MilkdropMessage | null;
+export declare function getMilkdropWindowEnabled(state: AppState): boolean;
+export declare function getMilkdropDesktopEnabled(state: AppState): boolean;
+export declare function getMilkdropFullscreenEnabled(state: AppState): boolean;
+export declare function getPresets(state: AppState): any;
+export declare function getButterchurn(state: AppState): any;
+export declare function getPresetTransitionType(state: AppState): TransitionType;
+export declare function getCurrentPresetIndex(state: AppState): number | null;
+export declare function getCurrentPreset(state: AppState): any | null;
+export declare function getPresetNames(state: AppState): string[];
+export declare function getPresetOverlayOpen(state: AppState): boolean;
+export declare function getPresetsAreCycling(state: AppState): boolean;
+export declare function getRandomizePresets(state: AppState): boolean;
+export declare function getClosed(state: AppState): boolean;
+export declare function getSkinImages(state: AppState): SkinImages;
+export declare function getSkinCursors(state: AppState): Cursors | null;
+export declare function getSkinRegion(state: AppState): SkinRegion;
+export declare function getSkinLetterWidths(state: AppState): GenLetterWidths | null;
+export declare function getPreampLineUrl(state: AppState): string | null;
+export declare function getLineColorsUrl(state: AppState): string | null;
+export declare const getPreampLineImage: import("reselect").OutputSelector<AppState, Promise<HTMLImageElement | null>, (res: string | null) => Promise<HTMLImageElement | null>>;
+export declare const getLineColorsImage: import("reselect").OutputSelector<AppState, Promise<HTMLImageElement | null>, (res: string | null) => Promise<HTMLImageElement | null>>;
+export declare function getDummyVizData(state: AppState): DummyVizData | null;
+export declare function getMarqueeStep(state: AppState): number;
+export declare function getNetworkConnected(state: AppState): boolean;
+export declare function getTimeMode(state: AppState): TimeMode;
+export declare function getLoading(state: AppState): boolean;
+export declare function getWorking(state: AppState): boolean;
+export declare function getAvaliableSkins(state: AppState): import("./types").Skin[];

package/built/types/js/selectors.test.d.ts

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

package/built/types/js/serialization.test.d.ts

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

package/built/types/js/serializedStates/v1Types.d.ts

@@ -0,0 +1,64 @@
+/**
+ * NOTE: This file must not import any other types
+ */
+import { WindowId } from "../types";
+export interface WindowsSerializedStateV1 {
+    positionsAreRelative: boolean;
+    genWindows: {
+        [windowId: string]: {
+            size: [number, number];
+            open: boolean;
+            hidden: boolean;
+            shade: boolean;
+            position: {
+                x: number;
+                y: number;
+            };
+        };
+    };
+    focused: WindowId | null;
+}
+export interface DisplaySerializedStateV1 {
+    visualizerStyle: number;
+    doubled: boolean;
+    llama: boolean;
+    marqueeStep: number;
+    skinImages: {
+        [sprite: string]: string;
+    };
+    skinCursors: {
+        [cursor: string]: string;
+    } | null;
+    skinRegion: {
+        [windowName: string]: string[];
+    };
+    skinGenLetterWidths: {
+        [letter: string]: number;
+    } | null;
+    skinColors: string[];
+    skinPlaylistStyle: {
+        normal: string;
+        current: string;
+        normalbg: string;
+        selectedbg: string;
+        font: string;
+    } | null;
+}
+export interface EqualizerSerializedStateV1 {
+    on: boolean;
+    auto: boolean;
+    sliders: Record<60 | 170 | 310 | 600 | 1000 | 3000 | 6000 | 12000 | 14000 | 16000 | "preamp", number>;
+}
+export interface MediaSerializedStateV1 {
+    volume: number;
+    balance: number;
+    shuffle: boolean;
+    repeat: boolean;
+}
+export interface SerializedStateV1 {
+    version: 1;
+    windows: WindowsSerializedStateV1;
+    media: MediaSerializedStateV1;
+    display: DisplaySerializedStateV1;
+    equalizer: EqualizerSerializedStateV1;
+}

package/built/types/js/skinParser.d.ts

@@ -0,0 +1,12 @@
+export default skinParser;
+declare function skinParser(zipFileBuffer: any, JSZip: any): Promise<{
+    colors: string[];
+    playlistStyle: import("./types").PlaylistStyle;
+    images: any;
+    genLetterWidths: {} | null;
+    cursors: any;
+    region: {
+        [section: string]: string[];
+    };
+    genExColors: import("./types").SkinGenExColors | null;
+}>;

package/built/types/js/skinParserUtils.d.ts

@@ -0,0 +1,19 @@
+import JSZip from "jszip";
+import { PlaylistStyle, SkinGenExColors, CursorImage } from "./types";
+import { Sprite } from "./skinSprites";
+export declare const getFileExtension: (fileName: string) => string | null;
+export declare function getFileFromZip(zip: JSZip, fileName: string, ext: string, mode: "blob" | "text" | "base64" | "uint8array"): Promise<{
+    contents: string | Uint8Array | Blob;
+    name: string;
+} | null>;
+export declare function getImgFromBlob(blob: Blob): Promise<ImageBitmap | HTMLImageElement | null>;
+export declare function getSpriteUrisFromImg(img: HTMLImageElement | ImageBitmap, sprites: Sprite[]): {
+    [spriteName: string]: string;
+};
+export declare function getImgFromFilename(zip: JSZip, fileName: string): Promise<HTMLImageElement | ImageBitmap | null>;
+export declare function getSpriteUrisFromFilename(zip: JSZip, fileName: string): Promise<{
+    [spriteName: string]: string;
+}>;
+export declare function getCursorFromFilename(zip: JSZip, fileName: string): Promise<CursorImage | null>;
+export declare function getPlaylistStyle(zip: JSZip): Promise<PlaylistStyle>;
+export declare function getGenExColors(zip: JSZip): Promise<null | SkinGenExColors>;

package/built/types/js/skinSelectors.d.ts

@@ -0,0 +1,6 @@
+interface Selectors {
+    [name: string]: string[];
+}
+export declare const imageSelectors: Selectors;
+export declare const cursorSelectors: Selectors;
+export {};

package/built/types/js/skinSprites.d.ts

@@ -0,0 +1,17 @@
+export type SpriteName = string;
+export interface Sprite {
+    name: SpriteName;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export declare const FONT_LOOKUP: {
+    [letter: string]: [number, number];
+};
+export declare const imageConstFromChar: (char: string) => string;
+interface SpriteMap {
+    [sheet: string]: Sprite[];
+}
+declare const sprites: SpriteMap;
+export default sprites;

package/built/types/js/snapUtils.d.ts

@@ -0,0 +1,32 @@
+import { Box, Point, Diff, BoundingBox } from "./types";
+export declare const SNAP_DISTANCE = 15;
+export declare const top: (box: Box) => number;
+export declare const bottom: (box: Box) => number;
+export declare const left: (box: Box) => number;
+export declare const right: (box: Box) => number;
+export declare const near: (a: number, b: number) => boolean;
+export declare const overlapX: (a: Box, b: Box) => boolean;
+export declare const overlapY: (a: Box, b: Box) => boolean;
+export declare const snap: (boxA: Box, boxB: Box) => {
+    x: number | undefined;
+    y: number | undefined;
+};
+export declare const snapDiff: (a: Box, b: Box) => Point;
+export declare const snapDiffManyToMany: (as: Box[], bs: Box[]) => Point;
+export declare const snapToMany: (boxA: Box, otherBoxes: Box[]) => Diff;
+export declare const snapWithin: (boxA: Box, boundingBox: BoundingBox) => Diff;
+export declare const snapWithinDiff: (a: Box, b: BoundingBox) => {
+    x: number;
+    y: number;
+};
+export declare const applySnap: (original: Point, ...snaps: Diff[]) => Diff;
+export declare const boundingBox: (nodes: Box[]) => Box;
+export declare function traceConnection<B extends Box>(areConnected: (candidate: Box, n: Box) => boolean): (candidates: B[], node: B) => Set<B>;
+export declare const applyDiff: (a: Point, b: Point) => {
+    x: number;
+    y: number;
+};
+export declare const applyMultipleDiffs: (initial: Point, ...diffs: Point[]) => {
+    x: number;
+    y: number;
+};

package/built/types/js/snapUtils.test.d.ts

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

package/built/types/js/spinParserUtils.test.d.ts

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

package/built/types/js/store.d.ts

@@ -0,0 +1,4 @@
+import Media from "./media";
+import Emitter from "./emitter";
+import { Extras, PartialState, Middleware, Store } from "./types";
+export default function createWebampStore(media: Media, actionEmitter: Emitter, customMiddlewares: Middleware[] | undefined, stateOverrides: PartialState | undefined, extras: Extras): Store;

package/built/types/js/trackUtils.d.ts

@@ -0,0 +1,3 @@
+import { PlaylistTrack } from "./types";
+export declare const trackName: (value: PlaylistTrack) => string;
+export declare const trackFilename: (value: PlaylistTrack) => string;