@halcyontech/vscode-ibmi-types 1.6.14 → 1.7.6

package/api/Configuration.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="vscode" />
+export declare type SourceDateMode = "edit" | "diff";
 export declare namespace GlobalConfiguration {
     function get<T>(prop: string): T | undefined;
     function set(key: string, value: any): Thenable<void>;
@@ -17,7 +18,7 @@ export declare namespace ConnectionConfiguration {
         autoConvertIFSccsid: boolean;
         hideCompileErrors: string[];
         enableSourceDates: boolean;
-        sourceDateMode: "edit" | "diff";
+        sourceDateMode: SourceDateMode;
         sourceDateGutter: boolean;
         encodingFor5250: string;
         terminalFor5250: string;
@@ -25,6 +26,11 @@ export declare namespace ConnectionConfiguration {
         connectringStringFor5250: string;
         autoSaveBeforeAction: boolean;
         showDescInLibList: boolean;
+        debugPort: string;
+        debugIsSecure: boolean;
+        debugUpdateProductionFiles: boolean;
+        debugEnableDebugTracing: boolean;
+        readOnlyMode: boolean;
         [name: string]: any;
     }
     interface ObjectFilters {
@@ -34,6 +40,7 @@ export declare namespace ConnectionConfiguration {
         types: string[];
         member: string;
         memberType: string;
+        protected: boolean;
     }
     interface CustomVariable {
         name: string;

package/api/CustomUI.d.ts

@@ -1,64 +1,92 @@
-export class CustomUI {
-    /** @type {Field[]} */
+import vscode from 'vscode';
+export interface Page<T> {
+    panel: vscode.WebviewPanel;
+    data?: T;
+}
+export interface Button {
+    id: string;
+    label: string;
+}
+export interface SelectItem {
+    text: string;
+    description: string;
+    value: string;
+    selected?: boolean;
+}
+export interface Tab {
+    label: string;
+    value: string;
+}
+export interface ComplexTab {
+    label: string;
     fields: Field[];
-    /**
-     * @param {Field} field
-     */
-    addField(field: Field): void;
+}
+export declare class Section {
+    readonly fields: Field[];
+    addHorizontalRule(): this;
+    addCheckbox(id: string, label: string, description?: string, checked?: boolean): this;
+    addInput(id: string, label: string, description?: string, options?: {
+        default?: string;
+        readonly?: boolean;
+        multiline?: boolean;
+    }): this;
+    addParagraph(label: string): this;
+    addFile(id: string, label: string, description?: string): this;
+    addPassword(id: string, label: string, description?: string, defaultValue?: string): this;
+    addTabs(tabs: Tab[], selected?: number): this;
+    addComplexTabs(tabs: ComplexTab[], selected?: number): this;
+    addSelect(id: string, label: string, items: SelectItem[], description?: string): this;
+    addTree(id: string, label: string, treeItems: TreeListItem[], description?: string): this;
+    addButtons(...buttons: Button[]): this;
+    addField(field: Field): this;
+}
+export declare class CustomUI extends Section {
     /**
      * If no callback is provided, a Promise will be returned
-     * @param {string} title
-     * @param {Function} [callback] ({panel, data}) => {}
-     * @returns {Promise<{panel: vscode.WebviewPanel, data: object}>}
+     * @param title
+     * @param callback
+     * @returns a Promise<Page<T>> if no callback is provided
      */
-    loadPage(title: string, callback?: Function): Promise<{
-        panel: vscode.WebviewPanel;
-        data: object;
-    }>;
-    getHTML(panel: any): string;
+    loadPage<T>(title: string, callback?: (page: Page<T>) => void): Promise<Page<T>> | undefined;
+    private getHTML;
 }
-export class Field {
-    /**
-     *
-     * @param {"input"|"password"|"submit"|"buttons"|"checkbox"|"file"|"tabs"|"tree"|"select"|"paragraph"|"hr"} type
-     * @param {string} [id]
-     * @param {string} [label]
-     */
-    constructor(type: "input" | "password" | "submit" | "buttons" | "checkbox" | "file" | "tabs" | "tree" | "select" | "paragraph" | "hr", id?: string, label?: string);
-    /** @type {"input"|"password"|"submit"|"buttons"|"checkbox"|"file"|"tabs"|"tree"|"select"|"paragraph"|"hr"} */
-    type: "input" | "password" | "submit" | "buttons" | "checkbox" | "file" | "tabs" | "tree" | "select" | "paragraph" | "hr";
-    /** @type {string} */
-    id: string;
-    /** @type {string} */
+export declare type FieldType = "input" | "password" | "submit" | "buttons" | "checkbox" | "file" | "complexTabs" | "tabs" | "tree" | "select" | "paragraph" | "hr";
+export interface TreeListItemIcon {
+    branch?: string;
+    open?: string;
+    leaf?: string;
+}
+export interface TreeListItem {
     label: string;
-    /** @type {string|undefined} */
-    description: string | undefined;
-    /** @type {string|undefined} */
-    default: string | undefined;
-    /**
-     * Used only for `input` type
-     * @type {boolean|undefined}
-    */
-    readonly: boolean | undefined;
-    /**
-     * Used only for `input` type
-     * @type {boolean|undefined}
-    */
-    multiline: boolean | undefined;
-    /** @type {{label: string, value: string}[]|{selected?: boolean, value: string, description: string, text: string}[]|{label: string, id: string}[]|undefined} Used for select & button types. */
-    items: {
-        label: string;
-        value: string;
-    }[] | {
-        selected?: boolean;
-        value: string;
-        description: string;
-        text: string;
-    }[] | {
-        label: string;
-        id: string;
-    }[];
-    treeList: any;
+    subItems?: TreeListItem[];
+    open?: boolean;
+    selected?: boolean;
+    focused?: boolean;
+    icons?: TreeListItemIcon;
+    value?: string;
+    path?: number[];
+}
+export interface FieldItem {
+    label?: string;
+    value?: string;
+    selected?: boolean;
+    description?: string;
+    text?: string;
+    id?: string;
+}
+export declare class Field {
+    readonly type: FieldType;
+    readonly id: string;
+    readonly label: string;
+    readonly description?: string;
+    items?: FieldItem[];
+    treeList?: TreeListItem[];
+    complexTabItems?: ComplexTab[];
+    default?: string;
+    readonly?: boolean;
+    multiline?: boolean;
+    constructor(type: FieldType, id: string, label: string, description?: string);
     getHTML(): string;
+    private renderLabel;
+    private renderDescription;
 }
-import vscode = require("vscode");

package/api/IBMi.d.ts

@@ -20,8 +20,7 @@ export default class IBMi {
         [name: string]: string;
     };
     defaultUserLibraries: string[];
-    outputChannel: vscode.OutputChannel;
-    subscriptions: vscode.Disposable[];
+    outputChannel?: vscode.OutputChannel;
     aspInfo: {
         [id: number]: string;
     };
@@ -55,7 +54,9 @@ export default class IBMi {
      */
     paseCommand(command: string, directory?: string, returnType?: number, standardIO?: StandardIO): Promise<String | CommandResult>;
     sendCommand(options: CommandData): Promise<CommandResult>;
+    private appendOutput;
     private determineClear;
+    end(): Promise<void>;
     /**
      * Generates path to a temp file on the IBM i
      * @param {string} key Key to the temp file to be re-used

package/api/Instance.d.ts

@@ -1,22 +1,22 @@
 import * as vscode from "vscode";
 import IBMi from "./IBMi";
 import IBMiContent from "./IBMiContent";
-import { Storage } from "./Storage";
+import { ConnectionStorage } from "./Storage";
 import { ConnectionConfiguration } from "./Configuration";
+import { IBMiEvent } from "../typings";
 export default class Instance {
-    connection: IBMi | undefined;
-    content: IBMiContent | undefined;
-    storage: Storage | undefined;
-    emitter: vscode.EventEmitter<any> | undefined;
-    events: {
-        event: string;
-        func: Function;
-    }[];
-    constructor();
+    private connection;
+    private content;
+    private storage;
+    private emitter;
+    private events;
+    constructor(context: vscode.ExtensionContext);
+    setConnection(connection?: IBMi): Promise<void>;
     getConnection(): IBMi;
     setConfig(newConfig: ConnectionConfiguration.Parameters): Promise<void>;
     getConfig(): ConnectionConfiguration.Parameters;
     getContent(): IBMiContent;
-    getStorage(): Storage;
-    onEvent(event: "connected" | "disconnected", func: Function): void;
+    getStorage(): ConnectionStorage;
+    onEvent(event: IBMiEvent, func: Function): void;
+    fire(event: IBMiEvent): void;
 }

package/api/Search.d.ts

@@ -3,11 +3,13 @@ export declare namespace Search {
     interface Result {
         path: string;
         lines: Line[];
+        filter?: string;
+        label?: string;
     }
     interface Line {
         number: number;
         content: string;
     }
-    function searchMembers(instance: Instance, library: string, sourceFile: string, memberFilter: string, searchTerm: string): Promise<Result[]>;
+    function searchMembers(instance: Instance, library: string, sourceFile: string, memberFilter: string, searchTerm: string, filter?: string): Promise<Result[]>;
     function searchIFS(instance: Instance, path: string, searchTerm: string): Promise<Result[]>;
 }

package/api/Storage.d.ts

@@ -1,12 +1,34 @@
 import vscode from 'vscode';
 export declare type PathContent = Record<string, string[]>;
 export declare type DeploymentPath = Record<string, string>;
-export declare class Storage {
-    readonly context: vscode.ExtensionContext;
-    readonly connectionName: string;
-    constructor(context: vscode.ExtensionContext, connectionName: string);
-    private get;
-    private set;
+export declare type DebugCommands = Record<string, string>;
+declare abstract class Storage {
+    protected readonly globalState: any;
+    constructor(context: vscode.ExtensionContext);
+    protected get<T>(key: string): T | undefined;
+    protected set(key: string, value: any): Promise<void>;
+    protected abstract getStorageKey(key: string): string;
+}
+export declare type LastConnection = {
+    name: string;
+    timestamp: number;
+};
+export declare class GlobalStorage extends Storage {
+    private static instance;
+    static initialize(context: vscode.ExtensionContext): void;
+    static get(): GlobalStorage;
+    private constructor();
+    protected getStorageKey(key: string): string;
+    getLastConnections(): LastConnection[];
+    setLastConnection(name: string): Promise<void>;
+    setLastConnections(lastConnections: LastConnection[]): Promise<void>;
+}
+export declare class ConnectionStorage extends Storage {
+    private connectionName;
+    constructor(context: vscode.ExtensionContext);
+    get ready(): boolean;
+    setConnectionName(connectionName: string): void;
+    protected getStorageKey(key: string): string;
     getSourceList(): PathContent;
     setSourceList(sourceList: PathContent): Promise<void>;
     getLastProfile(): string;
@@ -15,4 +37,7 @@ export declare class Storage {
     setPreviousCurLibs(previousCurLibs: string[]): Promise<void>;
     getDeployment(): DeploymentPath;
     setDeployment(existingPaths: DeploymentPath): Promise<void>;
+    getDebugCommands(): DebugCommands;
+    setDebugCommands(existingCommands: DebugCommands): Promise<void>;
 }
+export {};

package/api/Tools.d.ts

@@ -1,3 +1,4 @@
+import { API } from "./import/git";
 export declare namespace Tools {
     interface DB2Headers {
         name: string;
@@ -26,4 +27,5 @@ export declare namespace Tools {
      * @returns the escaped path
      */
     function escapePath(Path: string): string;
+    function getGitAPI(): API | undefined;
 }

package/api/debug/certificates.d.ts

@@ -0,0 +1,6 @@
+import IBMi from "../IBMi";
+export declare function getKeystorePath(): string;
+export declare function getLocalCertPath(connection: IBMi): string;
+export declare function checkRemoteExists(connection: IBMi): Promise<boolean>;
+export declare function setup(connection: IBMi): Promise<void>;
+export declare function checkLocalExists(connection: IBMi): Promise<boolean>;

package/api/debug/index.d.ts

@@ -0,0 +1,10 @@
+import { ExtensionContext } from "vscode";
+import Instance from "../Instance";
+export declare function initialize(context: ExtensionContext): Promise<void>;
+interface DebugOptions {
+    password: string;
+    library: string;
+    object: string;
+}
+export declare function startDebug(instance: Instance, options: DebugOptions): Promise<void>;
+export {};

package/api/debug/server.d.ts

@@ -0,0 +1,10 @@
+import IBMi from "../IBMi";
+import IBMiContent from "../IBMiContent";
+export declare function startup(connection: IBMi): Promise<void>;
+export declare function getRunningJob(localPort: string, content: IBMiContent): Promise<string | undefined>;
+export declare function end(connection: IBMi): Promise<void>;
+/**
+ * Gets a list of debug jobs stuck at MSGW in QSYSWRK
+ */
+export declare function getStuckJobs(userProfile: string, content: IBMiContent): Promise<string[]>;
+export declare function endJobs(jobIds: string[], connection: IBMi): Promise<import("../../typings").CommandResult[]>;

package/api/local/deployment.d.ts

@@ -1,8 +1,7 @@
 import vscode from 'vscode';
-import Instance from '../Instance';
 import { DeploymentParameters } from '../../typings';
 export declare namespace Deployment {
-    function initialize(context: vscode.ExtensionContext, instance: Instance): void;
+    function initialize(context: vscode.ExtensionContext): void;
     /**
      * Deploy a workspace to a remote IFS location.
      * @param workspaceIndex if no index is provided, a prompt will be shown to pick one if there are multiple workspaces,

package/extension.d.ts

@@ -1,4 +1,4 @@
 import { ExtensionContext } from "vscode";
 import { CodeForIBMi } from "./typings";
-export declare function activate(context: ExtensionContext): CodeForIBMi;
+export declare function activate(context: ExtensionContext): Promise<CodeForIBMi>;
 export declare function deactivate(): void;

package/instantiate.d.ts

@@ -1,14 +1,7 @@
 import * as vscode from "vscode";
 import Instance from "./api/Instance";
-import IBMi from "./api/IBMi";
 import { Search } from "./api/Search";
-export declare const instance: Instance;
-export declare function setupEmitter(): void;
-export declare function setConnection(conn: IBMi): void;
+export declare let instance: Instance;
 export declare function setSearchResults(term: string, results: Search.Result[]): void;
 export declare function disconnect(): Promise<boolean>;
 export declare function loadAllofExtension(context: vscode.ExtensionContext): Promise<void>;
-/**
- * Register event
- */
-export declare function on(event: string, func: Function): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@halcyontech/vscode-ibmi-types",
-  "version": "1.6.14",
+  "version": "1.7.6",
   "description": "Types for vscode-ibmi",
   "typings": "./typings.d.ts",
   "scripts": {

package/typings.d.ts

@@ -10,13 +10,7 @@ export interface CodeForIBMi {
     deploy: (parameters: DeploymentParameters) => Promise<boolean>;
     evfeventParser: (lines: string[]) => Map<string, FileError[]>;
 }
-export declare enum DeploymentMethod {
-    "all" = 0,
-    "staged" = 1,
-    "unstaged" = 2,
-    "changed" = 3,
-    "compare" = 4
-}
+export declare type DeploymentMethod = "all" | "staged" | "unstaged" | "changed" | "compare";
 export interface DeploymentParameters {
     method: DeploymentMethod;
     localFolder: Uri;
@@ -112,3 +106,8 @@ export interface FileError {
     text: string;
     code: string;
 }
+export interface QsysFsOptions {
+    filter?: string;
+    readonly?: boolean;
+}
+export declare type IBMiEvent = "connected" | "disconnected" | "deployLocation";