webamp 1.5.0 → 2.0.0

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

@@ -0,0 +1,71 @@
+/// <reference types="react" />
+import { WindowInfo } from "./types";
+interface Time {
+    minutesFirstDigit: string;
+    minutesSecondDigit: string;
+    secondsFirstDigit: string;
+    secondsSecondDigit: string;
+}
+interface IniData {
+    [section: string]: {
+        [key: string]: string;
+    };
+}
+export declare function imgFromUrl(url: string): Promise<HTMLImageElement>;
+export declare const getTimeObj: (time: number | null) => Time;
+export declare const getTimeStr: (time: number | null, truncate?: boolean) => string;
+export declare const parseViscolors: (text: string) => string[];
+export declare const parseIni: (text: string) => IniData;
+export declare const clamp: (value: number, min: number, max: number) => number;
+export declare const sum: (values: number[]) => number;
+export declare function base64FromDataArray(dataArray: Uint8Array): string;
+export declare const base64FromArrayBuffer: (arrayBuffer: ArrayBuffer) => string;
+export declare function downloadURI(uri: string, name: string): void;
+export declare const toPercent: (min: number, max: number, value: number) => number;
+export declare const percentToRange: (percent: number, min: number, max: number) => number;
+export declare const percentToIndex: (percent: number, length: number) => number;
+export declare const normalizeEqBand: (oldValue: number) => number;
+export declare const denormalizeEqBand: (oldValue: number) => number;
+export declare function merge<T extends object, S extends object>(target: T, source: S): T & S;
+export declare function segment<V>(min: number, max: number, value: number, newValues: V[]): V;
+export declare function shuffle<T>(array: T[]): T[];
+export declare function sort<T>(array: T[], iteratee: (value: T) => number | string): T[];
+export declare function moveSelected<V>(arr: V[], isSelected: (index: number) => boolean, offset: number): V[];
+export declare function spliceIn<T>(original: T[], start: number, newValues: T[]): T[];
+export declare function replaceAtIndex<T>(arr: T[], index: number, newValue: T): T[];
+export declare function debounce(func: Function, delay: number): Function;
+export declare function throttle(func: Function, delay: number): Function;
+export declare function uniqueId(): number;
+export declare function objectForEach<V>(obj: {
+    [key: string]: V;
+}, cb: (value: V, key: string) => void): void;
+export declare function objectMap<V, N>(obj: {
+    [key: string]: V;
+}, cb: (value: V, key: string) => N): {
+    [key: string]: N;
+};
+export declare function objectFilter<V>(obj: {
+    [key: string]: V;
+}, predicate: (value: V, key: string) => boolean): {
+    [key: string]: V;
+};
+export declare const calculateBoundingBox: (windows: WindowInfo[]) => {
+    left: number;
+    top: number;
+    bottom: number;
+    right: number;
+} | null;
+export declare function findLastIndex<T>(arr: T[], cb: (val: T) => boolean): number;
+export declare function getWindowSize(): {
+    width: number;
+    height: number;
+};
+export declare function getScreenSize(): {
+    width: number;
+    height: number;
+};
+type PosEvent = MouseEvent | TouchEvent | React.MouseEvent<HTMLElement> | React.TouchEvent<HTMLElement>;
+export declare function getX(e: PosEvent): number;
+export declare function getY(e: PosEvent): number;
+export declare function weakMapMemoize<T extends object, R>(func: (value: T) => R): (value: T) => R;
+export {};

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

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

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

@@ -0,0 +1,6 @@
+import { Options } from "./types";
+import WebampLazy, { PrivateOptions } from "./webampLazy";
+export type * from "./types";
+export default class Webamp extends WebampLazy {
+    constructor(options: Options & PrivateOptions);
+}

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

@@ -0,0 +1,156 @@
+import ReactDOM from "react-dom/client";
+import { Store, Track, LoadedURLTrack, Middleware, ButterchurnOptions, PartialState, Options, MediaStatus } from "./types";
+import Media from "./media";
+import Emitter from "./emitter";
+import { SerializedStateV1 } from "./serializedStates/v1Types";
+import Disposable from "./Disposable";
+export interface PrivateOptions {
+    __initialState?: PartialState;
+    __customMiddlewares?: Middleware[];
+    __butterchurnOptions?: ButterchurnOptions;
+    __customMediaClass?: typeof Media;
+}
+export interface InjectableDependencies {
+    requireJSZip: () => Promise<any>;
+    requireMusicMetadata: () => Promise<any>;
+}
+declare class Webamp {
+    static VERSION: string;
+    _actionEmitter: Emitter;
+    _root: ReactDOM.Root | null;
+    _disposable: Disposable;
+    options: Options & PrivateOptions & InjectableDependencies;
+    media: Media;
+    store: Store;
+    /**
+     * Returns a true if the current browser supports the features that Webamp depends upon.
+     *
+     * It is recommended to check this before you attempt to instantiate an instance of Winamp.
+     */
+    static browserIsSupported(): boolean;
+    constructor(options: Options & PrivateOptions & InjectableDependencies);
+    /**
+     * Play the current tack
+     */
+    play(): void;
+    /**
+     * Pause the current tack
+     */
+    pause(): void;
+    /**
+     * Stop the currently playing audio. Equivalent to pressing the "stop" button
+     */
+    stop(): void;
+    /**
+     * Set volume from 0 - 100
+     */
+    setVolume(volume: number): void;
+    /**
+     * Seek backward n seconds in the curent track
+     */
+    seekBackward(seconds: number): void;
+    /**
+     * Seek forward n seconds in the curent track
+     */
+    seekForward(seconds: number): void;
+    /**
+     * Seek to a given time within the current track
+     */
+    seekToTime(seconds: number): void;
+    /**
+     * Play the next track
+     */
+    nextTrack(): void;
+    /**
+     * Play the previous track
+     */
+    previousTrack(): void;
+    /**
+     * Add an array of `Track`s to the end of the playlist.
+     */
+    appendTracks(tracks: Track[]): void;
+    /**
+     * Replace the playlist with an array of `Track`s and begin playing the first track.
+     */
+    setTracksToPlay(tracks: Track[]): void;
+    /**
+     * Get the current "playing" status.
+     */
+    getMediaStatus(): MediaStatus | null;
+    /**
+     * A callback which will be called when Webamp is _about to_ close. Returns an
+     * "unsubscribe" function. The callback will be passed a `cancel` function
+     * which you can use to conditionally prevent Webamp from being closed.
+     *
+     * @returns An "unsubscribe" function. Useful if at some point in the future you want to stop listening to these events.
+     */
+    onWillClose(cb: (cancel: () => void) => void): () => void;
+    /**
+     * A callback which will be called when Webamp is closed.
+     *
+     * @returns An "unsubscribe" function. Useful if at some point in the future you want to stop listening to these events.
+     */
+    onClose(cb: () => void): () => void;
+    /**
+     * Equivalent to selection "Close" from Webamp's options menu. Once closed,
+     * you can open it again with `.reopen()`.
+     */
+    close(): void;
+    /**
+     * After `.close()`ing this instance, you can reopen it by calling this method.
+     */
+    reopen(): void;
+    /**
+     * A callback which will be called when a new track starts loading.
+     *
+     * This can happen on startup when the first track starts buffering, or when a subsequent track starts playing.
+     * The callback will be called with an object `({url: 'https://example.com/track.mp3'})` containing the URL of the track.
+     * Note: If the user drags in a track, the URL may be an ObjectURL.
+     *
+     * @returns An "unsubscribe" function. Useful if at some point in the future you want to stop listening to these events.
+     */
+    onTrackDidChange(cb: (trackInfo: LoadedURLTrack | null) => void): () => void;
+    /**
+     * A callback which will be called when Webamp is minimized.
+     *
+     * @returns An "unsubscribe" function. Useful if at some point in the future you want to stop listening to these events.
+     */
+    onMinimize(cb: () => void): () => void;
+    /**
+     * Set the skin to use. This can be a URL or a base64 encoded string. The skin
+     * will be loaded asynchronously.
+     *
+     * NOTE: If the URL is not on the same domain as the page, you will need to consider CORS.
+     * https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS
+     */
+    setSkinFromUrl(url: string): void;
+    /**
+     * Returns a promise that resolves when the skin is done loading.
+     */
+    skinIsLoaded(): Promise<void>;
+    /**
+     * Webamp will wait until it has fetched the skin and fully parsed it and then render itself.
+     *
+     * Webamp is rendered into a new DOM node at the end of the <body> tag with the id `#webamp`.
+     *
+     * If a domNode is passed, Webamp will place itself in the center of that DOM node.
+     *
+     * @returns A promise is returned which will resolve after the render is complete.
+     */
+    renderWhenReady(node: HTMLElement): Promise<void>;
+    /**
+     * **Note:** _This method is not fully functional. It is currently impossible to
+     * clean up a Winamp instance. This method makes an effort, but it still leaks
+     * the whole instance. In the future the behavior of this method will improve,
+     * so you might as well call it._
+     *
+     * When you are done with a Webamp instance, call this method and Webamp will
+     * attempt to clean itself up to avoid memory leaks.
+     */
+    dispose(): void;
+    __loadSerializedState(serializedState: SerializedStateV1): void;
+    __getSerializedState(): SerializedStateV1;
+    __onStateChange(cb: () => void): () => void;
+    _bufferTracks(tracks: Track[]): void;
+}
+export default Webamp;

package/built/types/scripts/postcss-optimize-data-uri-pngs.d.ts

@@ -0,0 +1,2 @@
+declare const _exports: any;
+export = _exports;

package/built/types/scripts/rollupPlugins.d.mts

@@ -0,0 +1,8 @@
+export function getPlugins({ minify, outputFile, vite }: {
+    minify: any;
+    outputFile: any;
+    vite: any;
+}): (import("rollup").Plugin<any> | {
+    name: string;
+    resolveId(source: any, importer: any): string | null;
+} | null)[];

package/built/types/vite.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig & Promise<import("vite").UserConfig> & import("vite").UserConfigFnObject & import("vite").UserConfigExport;
+export default _default;