custom-electron-titlebar 4.1.0 → 4.1.1-beta.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018 Alex Torres
+Copyright (c) 2018 - now Alex Torres
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -30,6 +30,17 @@ import { setupTitlebar, attachTitlebarToWindow } from "custom-electron-titlebar/
 setupTitlebar();
 
 function createWindow() {
+  // Create the browser window.
+  const mainWindow = new BrowserWindow({
+    width: 800,
+    height: 600,
+    titleBarStyle: 'hidden',
+    //frame: false, // needed if process.versions.electron < 14
+    webPreferences: {
+      preload: path.join(__dirname, 'preload.js')
+    }
+  });
+  
   ...
 
   // attach fullscreen(f11 and not 'maximized') && focus listeners

package/dist/enums/menu-state.d.ts

@@ -0,0 +1,6 @@
+export declare enum MenubarState {
+    HIDDEN = 0,
+    VISIBLE = 1,
+    FOCUSED = 2,
+    OPEN = 3
+}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import Titlebar from './titlebar';
-import { Color } from './common/color';
+import { Color } from 'vs/base/common/color';
 declare const _default: {
     Titlebar: typeof Titlebar;
     Color: typeof Color;

package/dist/{menu/menu.d.ts → menu.d.ts}

@@ -1,9 +1,9 @@
-import { Color } from "../common/color";
-import { IMenuItem } from "./menuitem";
-import { Disposable } from "../common/lifecycle";
-import { Event } from "../common/event";
 import { MenuItem } from "electron";
-import { MenubarOptions } from "../interfaces";
+import { Color } from "vs/base/common/color";
+import { IMenuItem } from "./menuitem";
+import { Disposable } from "vs/base/common/lifecycle";
+import { Event } from "vs/base/common/event";
+import { MenubarOptions } from "./types/menubar-options";
 export declare const MENU_MNEMONIC_REGEX: RegExp;
 export declare const MENU_ESCAPED_MNEMONIC_REGEX: RegExp;
 export interface IMenuOptions {
@@ -26,19 +26,19 @@ export declare class CETMenu extends Disposable {
     private focusedItem?;
     private menuContainer;
     private mnemonics;
-    private menubarOptions;
+    private menubarOptions?;
     private options;
     private closeSubMenu;
     private triggerKeys;
     parentData: ISubMenuData;
     private _onDidCancel;
     get onDidCancel(): Event<void>;
-    constructor(container: HTMLElement, menubarOptions: MenubarOptions, options?: IMenuOptions, closeSubMenu?: () => void);
+    constructor(container: HTMLElement, menubarOptions?: MenubarOptions, options?: IMenuOptions, closeSubMenu?: () => void);
     setAriaLabel(label: string): void;
     private isTriggerKeyEvent;
     private updateFocusedItem;
     getContainer(): HTMLElement;
-    createMenu(items: MenuItem[]): void;
+    createMenu(items: MenuItem[] | undefined): void;
     focus(index?: number): void;
     focus(selectFirst?: boolean): void;
     private focusNext;
@@ -47,7 +47,7 @@ export declare class CETMenu extends Disposable {
     private doTrigger;
     private cancel;
     dispose(): void;
-    style(style: IMenuStyle): void;
+    style(style: IMenuStyle | undefined): void;
     private focusItemByElement;
     private setFocusedItem;
 }

package/dist/menubar.d.ts

@@ -1,24 +1,23 @@
-import { IMenuStyle } from './menu/menu';
-import { Disposable } from './common/lifecycle';
-import { Event } from './common/event';
-import { MenubarOptions } from './interfaces';
-export declare class Menubar extends Disposable {
+import { IMenuStyle } from './menu';
+import { Event } from 'vs/base/common/event';
+import { MenubarOptions } from './types/menubar-options';
+export declare class Menubar {
     private container;
     private options?;
     private menuItems;
     private focusedMenu;
     private focusToReturn;
-    private _mnemonicsInUse;
-    private openedViaKeyboard;
-    private awaitingAltRelease;
-    private ignoreNextMouseUp;
+    private _mnemonicsInUse?;
+    private openedViaKeyboard?;
+    private awaitingAltRelease?;
+    private ignoreNextMouseUp?;
     private mnemonics;
     private _focusState;
     private _onVisibilityChange;
     private _onFocusStateChange;
-    private menuStyle;
+    private menuStyle?;
     private closeSubMenu;
-    constructor(container: HTMLElement, options?: MenubarOptions, closeSubMenu?: () => void);
+    constructor(container: HTMLElement, options?: MenubarOptions | undefined, closeSubMenu?: () => void);
     private registerListeners;
     setupMenubar(): void;
     private onClick;

package/dist/{menu/menuitem.d.ts → menuitem.d.ts}

@@ -1,9 +1,9 @@
-import { EventLike } from "../common/dom";
 import { MenuItem } from "electron";
+import { EventLike } from "vs/base/common/dom";
 import { IMenuStyle, IMenuOptions } from "./menu";
-import { KeyCode } from "../common/keyCodes";
-import { Disposable } from "../common/lifecycle";
-import { MenubarOptions } from "../interfaces";
+import { KeyCode } from "vs/base/common/keyCodes";
+import { Disposable } from "vs/base/common/lifecycle";
+import { MenubarOptions } from "./types/menubar-options";
 export interface IMenuItem {
     render(element: HTMLElement): void;
     isEnabled(): boolean;
@@ -13,20 +13,21 @@ export interface IMenuItem {
     dispose(): void;
 }
 export declare class CETMenuItem extends Disposable implements IMenuItem {
-    protected menubarOptions: MenubarOptions;
+    protected menubarOptions?: MenubarOptions;
     protected options: IMenuOptions;
-    protected menuStyle: IMenuStyle;
-    protected container: HTMLElement;
-    protected itemElement: HTMLElement;
+    protected menuStyle?: IMenuStyle;
+    protected container?: HTMLElement;
+    protected itemElement?: HTMLElement;
     private item;
-    private radioGroup;
-    private labelElement;
-    private iconElement;
-    private mnemonic;
+    private radioGroup?;
+    private labelElement?;
+    private iconElement?;
+    private mnemonic?;
     protected closeSubMenu: () => void;
-    protected menuContainer: IMenuItem[];
-    constructor(item: MenuItem, menubarOptions: MenubarOptions, options?: IMenuOptions, closeSubMenu?: () => void, menuContainer?: IMenuItem[]);
-    getContainer(): HTMLElement;
+    protected menuContainer?: IMenuItem[];
+    private menuIcons;
+    constructor(item: MenuItem, options?: IMenuOptions, menubarOptions?: MenubarOptions, closeSubMenu?: () => void, menuContainer?: IMenuItem[]);
+    getContainer(): HTMLElement | undefined;
     getItem(): MenuItem;
     isEnabled(): boolean;
     isSeparator(): boolean;
@@ -48,7 +49,7 @@ export declare class CETMenuItem extends Disposable implements IMenuItem {
         end: number;
     };
     dispose(): void;
-    getMnemonic(): KeyCode;
+    getMnemonic(): KeyCode | undefined;
     protected applyStyle(): void;
-    style(style: IMenuStyle): void;
+    style(style: IMenuStyle | undefined): void;
 }

package/dist/titlebar.d.ts

@@ -1,19 +1,19 @@
-import { Color } from './common/color';
 import { Menu } from 'electron';
-import { TitlebarOptions } from './interfaces';
+import { Color } from 'vs/base/common/color';
+import { TitlebarOptions } from './types/titlebar-options';
 export default class Titlebar {
-    private titlebar;
-    private dragRegion;
-    private windowIcon;
-    private title;
-    private menubarContainer;
-    private windowControls;
-    private maxRestoreControl;
-    private container;
-    private isInactive;
-    private menubar;
+    private titlebar?;
+    private dragRegion?;
+    private windowIcon?;
+    private title?;
+    private menubarContainer?;
+    private windowControls?;
+    private maxRestoreControl?;
+    private container?;
+    private isInactive?;
+    private menubar?;
     private options;
-    private resizer;
+    private resizer?;
     private defaultOptions;
     private platformIcons;
     constructor(titlebarOptions?: TitlebarOptions);
@@ -55,7 +55,7 @@ export default class Titlebar {
      * It method set new icon to title-bar-icon of title-bar.
      * @param path path to icon
      */
-    updateIcon(path: string): void;
+    updateIcon(path?: string): void;
     /**
      * Update the default menu or set a new menu.
      * @param menu The menu.

package/dist/types/custom-item.d.ts

@@ -0,0 +1,7 @@
+import { Menu, MenuItem } from "electron";
+export interface CustomItem {
+    menuItem: MenuItem;
+    buttonElement: HTMLElement;
+    titleElement: HTMLElement;
+    submenu?: Menu;
+}

package/dist/types/declaration.d.ts

@@ -0,0 +1,6 @@
+declare module "*.scss" {
+    const styles: {
+        [className: string]: string;
+    };
+    export default styles;
+}

package/dist/types/menubar-options.d.ts

@@ -0,0 +1,30 @@
+import { Menu } from "electron";
+import { Color } from "../vs/base/common/color";
+export interface MenubarOptions {
+    /**
+     * The menu to show in the title bar.
+     * You can use `Menu` or not add this option and the menu created in the main process will be taken.
+     * **The default menu is undefined**
+     */
+    menu?: Menu;
+    /**
+     * The position of menubar on titlebar.
+     * **The default is left**
+     */
+    menuPosition?: "left" | "bottom";
+    /**
+     * Enable the mnemonics on menubar and menu items
+     * **The default is true**
+     */
+    enableMnemonics?: boolean;
+    /**
+     * The background color when the mouse is over the item.
+     * **The default is undefined**
+     */
+    itemBackgroundColor?: Color;
+    /**
+     * The color of the svg icons in the menu
+     * **The default is black**
+     */
+    svgColor?: Color;
+}

package/dist/types/titlebar-options.d.ts

@@ -0,0 +1,61 @@
+import { Color } from "../vs/base/common/color";
+import { MenubarOptions } from "./menubar-options";
+export interface TitlebarOptions extends MenubarOptions {
+    /**
+     * The background color of titlebar.
+     * **The default is `#ffffff`**
+     */
+    backgroundColor?: Color;
+    /**
+     * The icon shown on the left side of titlebar.
+     * **The default is the favicon of the index.html**
+     */
+    icon?: string;
+    /**
+     * The icon size of titlebar. Value between 16 and 24.
+     * **The default is 16**
+     */
+    iconSize?: number;
+    /**
+     * The path of the icons of titlebar.
+     */
+    icons?: string;
+    /**
+     * The shadow color of titlebar.
+     */
+    shadow?: boolean;
+    /**
+     * Define if the minimize button is enabled.
+     * **The default is true**
+     */
+    minimizable?: boolean;
+    /**
+     * Define if the maximize and restore buttons are enabled.
+     * **The default is true**
+     */
+    maximizable?: boolean;
+    /**
+     * Define if the close button is enabled.
+     * **The default is true**
+     */
+    closeable?: boolean;
+    /**
+     * When the close button is clicked, the window is hidden instead of closed.
+     * **The default is false**
+     */
+    /**
+     * Set the order of the elements on the title bar. You can use `inverted`, `first-buttons` or don't add for.
+     * **The default is undefined**
+     */
+    order?: "inverted" | "first-buttons";
+    /**
+     * Set horizontal alignment of the window title.
+     * **The default value is center**
+     */
+    titleHorizontalAlignment?: "left" | "center" | "right";
+    /**
+     * Sets the value for the overflow of the container after title bar.
+     * **The default value is auto**
+     */
+    containerOverflow?: "auto" | "hidden" | "visible";
+}

package/dist/{browser → vs/base/browser}/browser.d.ts

@@ -1,6 +1,6 @@
-import { Event } from '../common/event';
-import { IDisposable } from '../common/lifecycle';
-import * as platform from '../common/platform';
+import { Event } from 'vs/base/common/event';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import * as platform from 'vs/base/common/platform';
 /** A zoom index, e.g. 1, 2, 3 */
 export declare function setZoomLevel(zoomLevel: number, isTrusted: boolean): void;
 export declare function getZoomLevel(): number;

package/dist/{browser → vs/base/browser}/event.d.ts

@@ -1,4 +1,4 @@
-import { Event } from '../common/event';
+import { Event } from 'vs/base/common/event';
 export declare type EventHandler = HTMLElement | HTMLDocument | Window;
 export interface IDomEvent {
     <K extends keyof HTMLElementEventMap>(element: EventHandler, type: K, useCapture?: boolean): Event<HTMLElementEventMap[K]>;

package/dist/{browser → vs/base/browser}/keyboardEvent.d.ts

@@ -1,4 +1,4 @@
-import { KeyCode, SimpleKeybinding } from '../common/keyCodes';
+import { KeyCode, SimpleKeybinding } from 'vs/base/common/keyCodes';
 export declare function getCodeForKeyCode(keyCode: KeyCode): number;
 export interface IKeyboardEvent {
     readonly browserEvent: KeyboardEvent;

package/dist/{common → vs/base/common}/async.d.ts

@@ -1,4 +1,4 @@
-import { Disposable } from './lifecycle';
+import { Disposable } from 'vs/base/common/lifecycle';
 export declare class TimeoutTimer extends Disposable {
     private _token;
     constructor();

package/dist/{common → vs/base/common}/color.d.ts

@@ -1,5 +1,4 @@
 export declare class RGBA {
-    _rgbaBrand: void;
     /**
      * Red: integer in [0-255]
      */
@@ -20,7 +19,6 @@ export declare class RGBA {
     static equals(a: RGBA, b: RGBA): boolean;
 }
 export declare class HSLA {
-    _hslaBrand: void;
     /**
      * Hue: integer in [0, 360]
      */
@@ -56,7 +54,6 @@ export declare class HSLA {
     static toRGBA(hsla: HSLA): RGBA;
 }
 export declare class HSVA {
-    _hsvaBrand: void;
     /**
      * Hue: integer in [0, 360]
      */
@@ -81,9 +78,9 @@ export declare class HSVA {
 export declare class Color {
     static fromHex(hex: string): Color;
     readonly rgba: RGBA;
-    private _hsla;
+    private _hsla?;
     get hsla(): HSLA;
-    private _hsva;
+    private _hsva?;
     get hsva(): HSVA;
     constructor(arg: RGBA | HSLA | HSVA);
     equals(other: Color): boolean;

package/dist/{common → vs/base/common}/dom.d.ts

@@ -1,7 +1,7 @@
-import { IKeyboardEvent } from '../browser/keyboardEvent';
-import { IMouseEvent } from '../browser/mouseEvent';
-import { Event } from './event';
-import { IDisposable } from './lifecycle';
+import { IKeyboardEvent } from 'vs/base/browser/keyboardEvent';
+import { IMouseEvent } from 'vs/base/browser/mouseEvent';
+import { Event } from 'vs/base/common/event';
+import { IDisposable } from 'vs/base/common/lifecycle';
 export declare function clearNode(node: HTMLElement): void;
 export declare function removeNode(node: HTMLElement): void;
 export declare function isInDOM(node: Node | null): boolean;
@@ -143,7 +143,7 @@ export interface EventLike {
     stopPropagation(): void;
 }
 export declare const EventHelper: {
-    stop: (e: EventLike, cancelBubble?: boolean) => void;
+    stop: (e: EventLike, cancelBubble?: boolean | undefined) => void;
 };
 export interface IFocusTracker {
     onDidFocus: Event<void>;

package/dist/{common → vs/base/common}/event.d.ts

@@ -1,5 +1,5 @@
-import { IDisposable } from './lifecycle';
-import { LinkedList } from './linkedList';
+import { IDisposable } from 'vs/base/common/lifecycle';
+import { LinkedList } from 'vs/base/common/linkedList';
 /**
  * To an event a function with one or zero parameters
  * can be subscribed. The event is the subscriber function itself.
@@ -148,7 +148,7 @@ export declare class Emitter<T> {
     private readonly _leakageMon?;
     private _disposed;
     private _event?;
-    private _deliveryQueue;
+    private _deliveryQueue?;
     protected _listeners?: LinkedList<Listener<T>>;
     constructor(options?: EmitterOptions);
     /**
@@ -167,7 +167,7 @@ export interface IWaitUntil {
     waitUntil(thenable: Promise<any>): void;
 }
 export declare class AsyncEmitter<T extends IWaitUntil> extends Emitter<T> {
-    private _asyncDeliveryQueue;
+    private _asyncDeliveryQueue?;
     fireAsync(eventFn: (thenables: Promise<any>[], listener: Function) => T): Promise<void>;
 }
 /**

package/dist/{common → vs/base/common}/iterator.d.ts

@@ -59,7 +59,7 @@ export interface INavigator<T> extends INextIterator<T> {
 }
 export declare class MappedNavigator<T, R> extends MappedIterator<T, R> implements INavigator<R> {
     protected navigator: INavigator<T>;
-    constructor(navigator: INavigator<T>, fn: (item: T) => R);
+    constructor(navigator: INavigator<T>, fn: (item: T | null) => R);
     current(): R;
     previous(): R;
     parent(): R;

package/dist/{common → vs/base/common}/keyCodes.d.ts

@@ -1,4 +1,4 @@
-import { OperatingSystem } from './platform';
+import { OperatingSystem } from 'vs/base/common/platform';
 /**
  * Virtual Key Codes, the value does not hold any inherent meaning.
  * Inspired somewhat from https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx

package/dist/{common → vs/base/common}/linkedList.d.ts

@@ -1,4 +1,4 @@
-import { Iterator } from './iterator';
+import { Iterator } from 'vs/base/common/iterator';
 export declare class LinkedList<E> {
     private _first;
     private _last;

package/dist/{common → vs/base/common}/platform.d.ts

@@ -21,17 +21,17 @@ export declare function isRootUser(): boolean;
  * the string is all lower case (e.g. zh-tw for Traditional
  * Chinese)
  */
-export declare const language: string;
+export declare const language: string | undefined;
 /**
  * The OS locale or the locale specified by --locale. The format of
  * the string is all lower case (e.g. zh-tw for Traditional
  * Chinese). The UI is not necessarily shown in the provided locale.
  */
-export declare const locale: string;
+export declare const locale: string | undefined;
 /**
  * The translatios that are available through language packs.
  */
-export declare const translationsConfigFile: string;
+export declare const translationsConfigFile: string | undefined;
 export declare const globals: any;
 export declare function setImmediate(callback: (...args: any[]) => void): number;
 export declare const enum OperatingSystem {