@prozilla-os/core 1.3.2 → 1.3.4

package/dist/main.d.ts

@@ -1,5 +1,3 @@
-/// <reference types="react" />
-
 import { FC } from 'react';
 import { HTMLAttributeAnchorTarget } from 'react';
 import { IconProp } from '@fortawesome/fontawesome-svg-core';
@@ -105,8 +103,17 @@ export declare class App<AppProps extends WindowProps = WindowProps> {
      * @default false
      */
     launchAtStartup: boolean;
+    /**
+     * The category the app belongs to
+     */
+    category: typeof APP_CATEGORIES[number] | null;
+    /**
+     * Metadata of the app's package
+     */
+    metadata: AppMetadata | null;
     isActive: boolean;
     isPinned?: boolean;
+    isInstalled: boolean;
     constructor(name: App["name"], id: App["id"], windowContent: App<AppProps>["windowContent"], windowOptions?: App["windowOptions"]);
     WindowContent: (props: AppProps) => JSX_2.Element | null;
     /**
@@ -137,20 +144,41 @@ export declare class App<AppProps extends WindowProps = WindowProps> {
      * Changes whether this application is launched at startup or not
      */
     setLaunchAtStartup(launchAtStartup: boolean): this;
+    /**
+     * Changes whether this application is installed by default or not
+     */
+    setInstalled(installed: boolean): this;
+    /**
+     * Changes the category this application belongs to
+     */
+    setCategory(category: typeof APP_CATEGORIES[number] | null): this;
+    setMetadata(metadata: AppMetadata | null): this;
+}
+
+export declare const APP_CATEGORIES: readonly ["Business", "Developer tools", "Education", "Entertainment", "Food & dining", "Health & fitness", "Kids & family", "Lifestyle", "Media", "Medical", "Multimedia design", "Music", "Navigation & maps", "News & weather", "Personal finance", "Personalization", "Photo & video", "Productivity", "Security", "Shopping", "Social", "Sports", "Travel", "Utilities & tools"];
+
+declare interface AppMetadata {
+    name: string;
+    version: `${number}.${number}.${number}`;
+    author: string;
 }
 
 export declare class AppsConfig {
     apps: AppsConfigOptions["apps"];
     static APP_ROLES: {
-        FileExplorer: string;
-        Terminal: string;
-        TextEditor: string;
-        Settings: string;
-        MediaViewer: string;
-        Browser: string;
+        fileExplorer: string;
+        terminal: string;
+        textEditor: string;
+        settings: string;
+        mediaViewer: string;
+        browser: string;
     };
     constructor(options?: OptionalInterface<AppsConfigOptions>);
-    getAppById(id: string): App | null;
+    get installedApps(): App<any>[];
+    /**
+     * @param includeUninstalled Include apps that are not currently installed
+     */
+    getAppById(id: string, includeUninstalled?: boolean): App | null;
     /**
      * Get the app associated with a file extension
      */
@@ -159,6 +187,10 @@ export declare class AppsConfig {
      * Get the app with a specific role
      */
     getAppByRole(role: string): App | null;
+    /**
+     * Get all applications (including uninstalled apps) that belong to a category
+     */
+    getAppsByCategory(category: typeof APP_CATEGORIES[number]): App[];
 }
 
 declare interface AppsConfigOptions {
@@ -244,15 +276,13 @@ declare interface DropdownActionProps extends ActionProps {
     showOnHover?: boolean;
 }
 
-export declare function DropdownButton({ label, options, shortcuts }: {
+export declare function DropdownButton({ label, options, shortcuts }: DropdownButtonProps): JSX_2.Element;
+
+declare interface DropdownButtonProps {
     label: string;
-    options: {
-        [s: string]: Function;
-    };
-    shortcuts: {
-        [s: string]: string[];
-    };
-}): JSX_2.Element;
+    options: Record<string, () => void>;
+    shortcuts: Record<string, string[]>;
+}
 
 declare class EventEmitter<EventMap extends EventNamesMap> {
     #private;
@@ -277,11 +307,16 @@ export declare type FileEventHandler = (event: Event, file: VirtualFile) => void
 
 export declare type FolderEventHandler = (event: Event, folder: VirtualFolder) => void;
 
+/**
+ * Formats a shortcut (combination of keys) into a human-readable format.
+ *
+ * For a list of valid key values, refer to this page: <https://developer.mozilla.org/en-US/docs/Web/API/UI_Events/Keyboard_event_key_values>
+ */
 export declare function formatShortcut(shortcut: string[]): string;
 
-export declare function generateUrl(options: generateUrlOptions): string;
+export declare function generateUrl(options: GenerateUrlOptions): string;
 
-declare interface generateUrlOptions {
+declare interface GenerateUrlOptions {
     appId?: string;
     fullscreen?: boolean;
     standalone?: boolean;
@@ -301,7 +336,7 @@ export declare function ImagePreview({ source, className, onError, ...props }: I
 declare interface ImagePreviewProps {
     source: string;
     className?: string;
-    onError?: Function;
+    onError?: () => void;
 }
 
 declare interface ImageProps {
@@ -313,8 +348,8 @@ declare interface ImageProps {
 export declare function Interactable({ onClick, onDoubleClick, children, ...props }: InteractableProps): JSX_2.Element;
 
 declare interface InteractableProps {
-    onClick: Function;
-    onDoubleClick: Function;
+    onClick?: (event: MouseEvent) => void;
+    onDoubleClick?: (event: MouseEvent) => void;
     children: ReactNode;
     [key: string]: unknown;
 }
@@ -342,7 +377,7 @@ declare class Modal {
     modalsManager: ModalsManager | null;
     element: FC<ModalProps> | null;
     props: object;
-    callback: Function | null;
+    callback: ((...args: unknown[]) => void) | null;
     id: number | null;
     dismissible: boolean;
     lastInteraction?: number;
@@ -373,7 +408,7 @@ export declare interface ModalProps {
         [key: string]: unknown;
     };
     children?: ReactNode;
-    onFinish?: Function;
+    onFinish?: () => void;
     [key: string]: unknown;
 }
 
@@ -381,7 +416,7 @@ export declare class ModalsConfig {
     defaultDialogSize: ModalsConfigOptions["defaultDialogSize"];
     defaultFileSelectorSize: ModalsConfigOptions["defaultFileSelectorSize"];
     static DIALOG_CONTENT_TYPES: {
-        CloseButton: number;
+        closeButton: number;
     };
     constructor(options?: OptionalInterface<ModalsConfigOptions>);
 }
@@ -402,14 +437,14 @@ declare interface ModalsConfigOptions {
 export declare class ModalsManager {
     modals: Record<string, Modal>;
     containerRef?: MutableRefObject<HTMLElement>;
-    updateModals: Function;
+    updateModals: (modals: ModalsManager["modals"]) => void;
     /**
      * @param single - Set to false to preserve other open modals
      */
     open(modal: Modal, single?: boolean): void;
     close(modalId: string | number, sendModalsUpdate?: boolean): void;
     focus(modalId: string): void;
-    setUpdateModals(updateModals: Function): void;
+    setUpdateModals(updateModals: ModalsManager["updateModals"]): void;
     get modalIds(): string[];
     static getModalIconUrl(name: string): string;
 }
@@ -435,9 +470,9 @@ declare interface OpenWindowedModalParams {
     iconUrl?: string;
     title?: string;
     size: Vector2;
-    Modal: Function;
+    Modal: FC<ModalProps>;
     single?: boolean;
-    fullscreen?: boolean;
+    fullscreen?: WindowProps["fullscreen"];
 }
 
 export declare type OptionalInterface<Interface> = {
@@ -511,14 +546,17 @@ declare interface RadioActionProps extends ActionProps {
  */
 export declare function reloadViewport(): void;
 
+export declare function removeBaseUrl(url: string): string;
+
 export declare function removeUrlProtocol(url: string): string;
 
-export declare function Router({ path, homePage, fallbackPage }: RouterProps): JSX_2.Element;
+export declare function Router({ path, homePage, fallbackPage, children }: RouterProps): JSX_2.Element;
 
 declare interface RouterProps {
     path?: string;
     homePage?: JSX.Element;
     fallbackPage?: JSX.Element;
+    children?: ReactElement;
 }
 
 declare class Settings {
@@ -561,6 +599,7 @@ export declare function setViewportTitle(title: string): void;
 export declare function Share({ modal, params, ...props }: ModalProps): JSX_2.Element;
 
 declare class Skin {
+    systemIcon: SkinOptions["systemIcon"];
     appIcons: SkinOptions["appIcons"];
     appNames: SkinOptions["appNames"];
     wallpapers: SkinOptions["wallpapers"];
@@ -568,10 +607,17 @@ declare class Skin {
     fileIcons: SkinOptions["fileIcons"];
     folderIcons: SkinOptions["folderIcons"];
     loadStyleSheet: SkinOptions["loadStyleSheet"];
+    defaultTheme: SkinOptions["defaultTheme"];
     constructor(options?: OptionalInterface_2<SkinOptions>);
 }
 
 declare interface SkinOptions {
+    /**
+     * SVG icon for the system
+     * @default
+     * "https://os.prozilla.dev/icon.svg"
+     */
+    systemIcon: string;
     /**
      * Replacements for app icons based on app id
      */
@@ -602,6 +648,7 @@ declare interface SkinOptions {
         info?: string;
         text?: string;
         code?: string;
+        external?: string;
     };
     /**
      * URLs of icons for types of folders
@@ -616,6 +663,10 @@ declare interface SkinOptions {
      * Function that dynamically imports style sheet
      */
     loadStyleSheet?: () => void;
+    /**
+     * Default theme
+     */
+    defaultTheme?: Theme;
 }
 
 export declare function StandaloneRoute({ app }: StandaloneRouteProps): JSX_2.Element;
@@ -647,7 +698,7 @@ export declare class SystemManager {
     readonly trackingConfig: TrackingConfig;
     readonly windowsConfig: WindowsConfig;
     readonly virtualDriveConfig: VirtualDriveConfig;
-    constructor({ systemName, tagLine, skin, desktopConfig, appsConfig, miscConfig, modalsConfig, taskbarConfig, trackingConfig, windowsConfig, virtualDriveConfig }: SystemManagerParams);
+    constructor({ systemName, tagLine, skin, desktopConfig, appsConfig, miscConfig, modalsConfig, taskbarConfig, trackingConfig, windowsConfig, virtualDriveConfig, }: SystemManagerParams);
     private loadSkin;
     getUptime(precision?: number): string;
 }
@@ -687,11 +738,24 @@ declare interface TextDisplayProps {
     children: ReactNode;
 }
 
-export declare const THEMES: Record<number, string | null>;
+declare enum Theme {
+    Dark = 0,
+    Light = 1,
+    Cherry = 2,
+    Mango = 3,
+    Aqua = 4,
+    Grape = 5
+}
 
 export declare class TimeManager {
-    static startDate: Date;
+    static START_DATE: Date;
+    /**
+     * Resets the time
+     */
     static reset(): void;
+    /**
+     * Get the current uptime
+     */
     static getUptime(precision?: number): string;
 }
 
@@ -703,7 +767,7 @@ declare interface ToggleActionProps extends ActionProps {
 
 export declare class TrackingConfig {
     enabled: TrackingConfigOptions["enabled"];
-    GAMeasurementId: TrackingConfigOptions["GAMeasurementId"];
+    googleAnalyticsMeasurementId: TrackingConfigOptions["GAMeasurementId"];
     constructor(options?: OptionalInterface<TrackingConfigOptions>);
 }
 
@@ -734,7 +798,7 @@ export declare function useAlert(): {
 export declare function useAppFolder(app?: App): VirtualFolder | null;
 
 /**
- * Combine clas names and an optional static class name
+ * Combine class names and an optional static class name
  */
 export declare function useClassNames(classNames: (string | undefined)[], block?: string, element?: string, modifier?: string | string[]): string;
 
@@ -750,9 +814,9 @@ declare interface UseContextMenuParams {
 export declare function useHistory<Type>(initialState: Type): {
     history: Type[];
     stateIndex: number;
-    pushState: Function;
-    undo: Function;
-    redo: Function;
+    pushState: (state: Type) => void;
+    undo: () => void;
+    redo: () => void;
     undoAvailable: boolean;
     redoAvailable: boolean;
 };
@@ -819,7 +883,7 @@ export declare function useSettingsManager(): SettingsManagerState;
 export declare function useShortcuts({ options, shortcuts, useCategories }: UseShortcutsParams): void;
 
 declare interface UseShortcutsParams {
-    options: Record<string, Record<string, Function>> | Record<string, Function>;
+    options: Record<string, Record<string, (event: KeyboardEvent) => void>> | Record<string, (event: KeyboardEvent) => void>;
     shortcuts?: Record<string, Record<string, string[]>> | Record<string, string[]>;
     useCategories?: boolean;
 }
@@ -893,7 +957,7 @@ declare class VirtualBase extends EventEmitter<EventNamesMap> {
     open(..._args: unknown[]): unknown;
     get path(): string;
     /**
-     * Returns path without using alias
+     * Returns path without using this item's alias
      */
     get displayPath(): string;
     /**
@@ -917,10 +981,43 @@ declare interface VirtualBaseJson {
 }
 
 export declare class VirtualDriveConfig {
+    saveData: VirtualDriveConfigOptions["saveData"];
+    defaultData: VirtualDriveConfigOptions["defaultData"];
     constructor(options?: OptionalInterface<VirtualDriveConfigOptions>);
 }
 
 declare interface VirtualDriveConfigOptions {
+    /**
+     * Enables persistent storage of the virtual drive
+     * @default true
+     */
+    saveData: boolean;
+    /**
+     * Configure the data that is loaded initially when ProzillaOS is opened
+     */
+    defaultData: {
+        /**
+         * Include pictures folder in default data
+         * @default true
+         */
+        includePicturesFolder?: boolean;
+        /**
+         * Include documents folder in default data
+         * @default true
+         */
+        includeDocumentsFolder?: boolean;
+        /**
+         * Include desktop folder in default data
+         * @default true
+         */
+        includeDesktopFolder?: boolean;
+        /**
+         * Include source tree folder in default data
+         * @default true
+         */
+        includeSourceTree?: boolean;
+        loadData?: (virtualRoot: VirtualRoot) => void;
+    };
 }
 
 /**
@@ -932,9 +1029,9 @@ export declare class VirtualFile extends VirtualBase {
     content: OptionalStringProperty;
     static NON_TEXT_EXTENSIONS: string[];
     static EVENT_NAMES: {
-        CONTENT_CHANGE: string;
+        contentChange: string;
     };
-    constructor(name: string, extension?: string | undefined);
+    constructor(name: string, extension?: string);
     setAlias(alias: string): this;
     /**
      * Sets the source of this file and removes the content
@@ -958,6 +1055,7 @@ export declare class VirtualFile extends VirtualBase {
     getIconUrl(): string;
     getType(): string;
     toJSON(): VirtualFileJson | null;
+    static removeFileScheme(source: string): string;
 }
 
 declare interface VirtualFileJson extends VirtualBaseJson {
@@ -997,8 +1095,8 @@ export declare class VirtualFolder extends VirtualBase {
     files: (VirtualFile | VirtualFileLink)[];
     type: number | undefined;
     static TYPE: {
-        GENERAL: number;
-        MEDIA: number;
+        general: number;
+        media: number;
     };
     constructor(name: string, type?: number);
     setAlias(alias: string): this;
@@ -1034,9 +1132,9 @@ export declare class VirtualFolder extends VirtualBase {
      */
     createFileLink(name: string, callback?: (newFileLink: VirtualFileLink | VirtualFile) => void): this;
     /**
-     * Creates files based on an array of objects with file names and extensions
+     * Creates file links based on an array of objects with file names and extensions
      */
-    createFileLinks(files: {
+    createFileLinks(fileLinks: {
         name: string;
     }[]): this;
     /**
@@ -1073,16 +1171,19 @@ export declare class VirtualFolder extends VirtualBase {
     delete(): void;
     /**
      * Returns all files inside this folder
+     * @param showHidden Whether to include hidden files
      */
     getFiles(showHidden?: boolean): VirtualFile[];
     /**
      * Returns all sub-folders inside this folder
+     * @param showHidden Whether to include hidden folders
      */
     getSubFolders(showHidden?: boolean): VirtualFolder[];
     /**
-     * Returns the amount of files and  sub-folders inside this folder
+     * Returns the amount of files and sub-folders inside this folder
+     * @param includeHidden Whether to include hidden files and folders in the count
      */
-    getItemCount(showHidden?: boolean): number;
+    getItemCount(includeHidden?: boolean): number;
     isFolder(): boolean;
     getIconUrl(): string;
     toJSON(): VirtualFolderJson | null;
@@ -1132,7 +1233,7 @@ export declare class VirtualRoot extends VirtualFolder {
     loadedDefaultData: boolean;
     systemManager: SystemManager;
     static EVENT_NAMES: {
-        ERROR: string;
+        error: string;
     };
     constructor(systemManager: SystemManager);
     loadDefaultData(): void;
@@ -1192,14 +1293,14 @@ declare interface WindowOptions {
 
 export declare interface WindowProps extends WindowOptions {
     fullscreen?: boolean;
-    onInteract?: Function;
+    onInteract?: () => void;
     setTitle?: React.Dispatch<React.SetStateAction<string>>;
     setIconUrl?: React.Dispatch<React.SetStateAction<string>>;
     close?: (event?: Event) => void;
     focus?: (event: Event, force?: boolean) => void;
     active?: boolean;
     minimized?: boolean;
-    toggleMinimized?: Function;
+    toggleMinimized?: (event?: Event) => void;
     index?: number;
     standalone?: boolean;
 }
@@ -1232,24 +1333,53 @@ export declare class WindowsManager {
     windows: {
         [id: string]: WindowOptions;
     };
-    updateWindows: Function;
+    updateWindows: (window: WindowsManager["windows"]) => void;
     startupComplete: boolean;
     constructor(systemManager: SystemManager, trackingManager: TrackingManager);
+    /**
+     * Open a window for an app
+     */
     open(appId: string, options?: WindowOptions | null): object | null;
+    /**
+     * Opens a file with the associated app or by a method specified by the file scheme
+     * @returns Opened window
+     */
     openFile(file: VirtualFile, options?: object): object | null;
+    /**
+     * Close a window
+     */
     close(windowId: string): void;
+    /**
+     * Focus on a specific window
+     */
     focus(windowId: string): void;
+    /**
+     * Check whether a window is focused
+     */
     isFocused(windowId: string): boolean | undefined;
+    /**
+     * Check if any window is focused
+     */
     isAnyFocused(): boolean;
     /**
+     * Change the minimized state of a window
      * @param minimized - Leave as undefined to toggle the window's minimization state
      */
     setMinimized(windowId: string, minimized?: boolean): void;
+    /**
+     * Minimize all windows
+     */
     minimizeAll(): void;
+    /**
+     * Check if an app has an open window
+     */
     isAppActive(appId: string): boolean;
+    /**
+     * Get an opened window of a certain app
+     */
     getAppWindowId(appId: string): string | null;
-    setUpdateWindows(updateWindows: Function): void;
-    startup(appIds: string[], options: {}): void;
+    setUpdateWindows(updateWindows: WindowsManager["updateWindows"]): void;
+    startup(appIds: string[], options: Record<string, unknown>): void;
     get windowIds(): string[];
 }