@halcyontech/vscode-ibmi-types 1.6.0 → 1.6.2

package/api/Configuration.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="vscode" />
+export declare namespace GlobalConfiguration {
+    function get<T>(prop: string): T | undefined;
+    function set(key: string, value: any): Thenable<void>;
+}
+export declare namespace ConnectionConfiguration {
+    interface Parameters extends ConnectionProfile {
+        host: string;
+        autoClearTempData: boolean;
+        connectionProfiles: ConnectionProfile[];
+        autoSortIFSShortcuts: boolean;
+        enableSQL: boolean;
+        tempLibrary: string;
+        tempDir: string;
+        sourceASP: string;
+        sourceFileCCSID: string;
+        autoConvertIFSccsid: boolean;
+        hideCompileErrors: string[];
+        enableSourceDates: boolean;
+        sourceDateMode: "edit" | "diff";
+        sourceDateGutter: boolean;
+        encodingFor5250: string;
+        terminalFor5250: string;
+        setDeviceNameFor5250: boolean;
+        connectringStringFor5250: string;
+        autoSaveBeforeAction: boolean;
+        showDescInLibList: boolean;
+        [name: string]: any;
+    }
+    interface ObjectFilters {
+        name: string;
+        library: string;
+        object: string;
+        types: string[];
+        member: string;
+        memberType: string;
+    }
+    interface CustomVariable {
+        name: string;
+        value: string;
+    }
+    interface ConnectionProfile {
+        name: string;
+        homeDirectory: string;
+        currentLibrary: string;
+        libraryList: string[];
+        objectFilters: ObjectFilters[];
+        ifsShortcuts: string[];
+        customVariables: CustomVariable[];
+    }
+    function update(parameters: Parameters): Promise<void>;
+    /**
+     * Will load an existing config if it exists, otherwise will create it with default values.
+     * @param name Connection name string for configuration
+     * @returns the parameters
+     */
+    function load(name: string): Promise<Parameters>;
+}

package/api/CustomUI.d.ts

@@ -0,0 +1,64 @@
+export class CustomUI {
+    /** @type {Field[]} */
+    fields: Field[];
+    /**
+     * @param {Field} field
+     */
+    addField(field: Field): void;
+    /**
+     * 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}>}
+     */
+    loadPage(title: string, callback?: Function): Promise<{
+        panel: vscode.WebviewPanel;
+        data: object;
+    }>;
+    getHTML(panel: any): string;
+}
+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} */
+    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;
+    getHTML(): string;
+}
+import vscode = require("vscode");

package/api/IBMi.d.ts

@@ -0,0 +1,76 @@
+import * as vscode from "vscode";
+import * as node_ssh from "node-ssh";
+import { ConnectionConfiguration } from "./Configuration";
+import { ConnectionData, CommandData, StandardIO, CommandResult } from "../typings";
+interface MemberParts {
+    asp: string | undefined;
+    library: string | undefined;
+    file: string | undefined;
+    member: string | undefined;
+    extension: string | undefined;
+    basename: string | undefined;
+}
+export default class IBMi {
+    client: node_ssh.NodeSSH;
+    currentHost: string;
+    currentPort: number;
+    currentUser: string;
+    currentConnectionName: string;
+    tempRemoteFiles: {
+        [name: string]: string;
+    };
+    defaultUserLibraries: string[];
+    outputChannel: vscode.OutputChannel;
+    subscriptions: vscode.Disposable[];
+    aspInfo: {
+        [id: number]: string;
+    };
+    qccsid: number | null;
+    remoteFeatures: {
+        [name: string]: string | undefined;
+    };
+    variantChars: {
+        american: string;
+        local: string;
+    };
+    lastErrors: object[];
+    config?: ConnectionConfiguration.Parameters;
+    commandsExecuted: number;
+    constructor();
+    /**
+     * @returns {Promise<{success: boolean, error?: any}>} Was succesful at connecting or not.
+     */
+    connect(connectionObject: ConnectionData): Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+    /**
+     * @param {string} command
+     * @param {string} [directory] If not passed, will use current home directory
+     */
+    remoteCommand(command: string, directory?: string): Promise<String | CommandResult>;
+    sendQsh(options: CommandData): Promise<CommandResult>;
+    /**
+     * @deprecated Use sendCommand instead
+     */
+    paseCommand(command: string, directory?: string, returnType?: number, standardIO?: StandardIO): Promise<String | CommandResult>;
+    sendCommand(options: CommandData): Promise<CommandResult>;
+    private determineClear;
+    /**
+     * Generates path to a temp file on the IBM i
+     * @param {string} key Key to the temp file to be re-used
+     */
+    getTempRemote(key: string): string;
+    parserMemberPath(string: string): MemberParts;
+    /**
+     * @param {string} string
+     * @returns {string} result
+     */
+    sysNameInLocal(string: string): string;
+    /**
+     * @param {string} string
+     * @returns {string} result
+     */
+    sysNameInAmerican(string: string): string;
+}
+export {};

package/api/IBMiContent.d.ts

@@ -0,0 +1,109 @@
+/// <reference types="node" />
+export = IBMiContent;
+declare class IBMiContent {
+    /**
+     * @param {IBMi} instance
+     */
+    constructor(instance: IBMi);
+    ibmi: IBMi;
+    /**
+     * @param {string} remotePath
+     * @param {string} localPath
+     */
+    downloadStreamfile(remotePath: string, localPath?: string): Promise<string>;
+    writeStreamfile(originalPath: any, content: any): Promise<void | String | import("../typings").CommandResult>;
+    /**
+     * Download the contents of a source member
+     * @param {string|undefined} asp
+     * @param {string} lib
+     * @param {string} spf
+     * @param {string} mbr
+     */
+    downloadMemberContent(asp: string | undefined, lib: string, spf: string, mbr: string): Promise<string>;
+    /**
+     * Upload to a member
+     * @param {string|undefined} asp
+     * @param {string} lib
+     * @param {string} spf
+     * @param {string} mbr
+     * @param {string|Uint8Array} content
+     */
+    uploadMemberContent(asp: string | undefined, lib: string, spf: string, mbr: string, content: string | Uint8Array): Promise<boolean>;
+    /**
+     * Run an SQL statement
+     * @param {string} statement
+     * @returns {Promise<Tools.DB2Row[]>} Result set
+     */
+    runSQL(statement: string): Promise<Tools.DB2Row[]>;
+    /**
+     * Download the contents of a table.
+     * @param {string} lib
+     * @param {string} file
+     * @param {string} [mbr] Will default to file provided
+     * @param {boolean} [deleteTable] Will delete the table after download
+     */
+    getTable(lib: string, file: string, mbr?: string, deleteTable?: boolean): Promise<any>;
+    /**
+     * Get list of libraries with description and attribute
+     * @param {string[]} libraries Array of libraries to retrieve
+     * @returns {Promise<{name: string, text: string, attribute: string}[]>} List of libraries
+     */
+    getLibraryList(libraries: string[]): Promise<{
+        name: string;
+        text: string;
+        attribute: string;
+    }[]>;
+    /**
+     * @param {{library: string, object?: string, types?: string[]}} filters
+     * @param {string?} sortOrder
+     * @returns {Promise<{library: string, name: string, type: string, text: string, attribute: string, count?: number}[]>} List of members
+     */
+    getObjectList(filters: {
+        library: string;
+        object?: string;
+        types?: string[];
+    }, sortOrder?: string | null): Promise<{
+        library: string;
+        name: string;
+        type: string;
+        text: string;
+        attribute: string;
+        count?: number;
+    }[]>;
+    /**
+     * @param {string} lib
+     * @param {string} spf
+     * @param {string} [mbr]
+     * @returns {Promise<{asp?: string, library: string, file: string, name: string, extension: string, recordLength: number, text: string}[]>} List of members
+     */
+    getMemberList(lib: string, spf: string, mbr?: string, ext?: string): Promise<{
+        asp?: string;
+        library: string;
+        file: string;
+        name: string;
+        extension: string;
+        recordLength: number;
+        text: string;
+    }[]>;
+    /**
+     * Get list of items in a path
+     * @param {string} remotePath
+     * @return {Promise<{type: "directory"|"streamfile", name: string, path: string}[]>} Resulting list
+     */
+    getFileList(remotePath: string): Promise<{
+        type: "directory" | "streamfile";
+        name: string;
+        path: string;
+    }[]>;
+    /**
+     * @param {string} errorsString
+     * @returns {{code: string, text: string}[]} errors
+     */
+    parseIBMiErrors(errorsString: string): {
+        code: string;
+        text: string;
+    }[];
+}
+import { default as IBMi } from "./IBMi";
+import { Tools } from "./Tools";
+import path = require("path");

package/api/Instance.d.ts

@@ -0,0 +1,21 @@
+import * as vscode from "vscode";
+import IBMi from "./IBMi";
+import IBMiContent from "./IBMiContent";
+import { Storage } from "./Storage";
+import { ConnectionConfiguration } from "./Configuration";
+export default class Instance {
+    connection: IBMi | undefined;
+    content: IBMiContent | undefined;
+    storage: Storage | undefined;
+    emitter: vscode.EventEmitter<any> | undefined;
+    events: {
+        event: string;
+        func: Function;
+    }[];
+    constructor();
+    getConnection(): IBMi;
+    setConfig(newConfig: ConnectionConfiguration.Parameters): Promise<void>;
+    getConfig(): ConnectionConfiguration.Parameters;
+    getContent(): IBMiContent;
+    getStorage(): Storage;
+}

package/api/Search.d.ts

@@ -0,0 +1,13 @@
+import Instance from './Instance';
+export declare namespace Search {
+    interface Result {
+        path: string;
+        lines: Line[];
+    }
+    interface Line {
+        number: number;
+        content: string;
+    }
+    function searchMembers(instance: Instance, library: string, sourceFile: string, memberFilter: string, searchTerm: string): Promise<Result[]>;
+    function searchIFS(instance: Instance, path: string, searchTerm: string): Promise<Result[]>;
+}

package/api/Storage.d.ts

@@ -0,0 +1,18 @@
+import vscode from 'vscode';
+export interface PathContent extends Record<string, string[]> {
+}
+export declare class Storage {
+    readonly context: vscode.ExtensionContext;
+    readonly connectionName: string;
+    constructor(context: vscode.ExtensionContext, connectionName: string);
+    private get;
+    private set;
+    getSourceList(): PathContent;
+    setSourceList(sourceList: PathContent): Promise<void>;
+    getLastProfile(): string;
+    setLastProfile(lastProfile: string): Promise<void>;
+    getPreviousCurLibs(): string[];
+    setPreviousCurLibs(previousCurLibs: string[]): Promise<void>;
+    getDeployment(): PathContent;
+    setDeployment(existingPaths: PathContent): Promise<void>;
+}

package/api/Terminal.d.ts

@@ -0,0 +1,4 @@
+import Instance from './Instance';
+export declare namespace Terminal {
+    function selectAndOpen(instance: Instance): void;
+}

package/api/Tools.d.ts

@@ -0,0 +1,29 @@
+export declare namespace Tools {
+    interface DB2Headers {
+        name: string;
+        from: number;
+        length: number;
+    }
+    interface DB2Row extends Record<string, string | number | null> {
+    }
+    /**
+     * Parse standard out for `/usr/bin/db2`
+     * @param output /usr/bin/db2's output
+     * @returns rows
+     */
+    function db2Parse(output: string): DB2Row[];
+    function makeid(): string;
+    /**
+     * Build the IFS path string to a member
+     * @param library
+     * @param object
+     * @param member
+     * @param iasp Optional: an iASP name
+     */
+    function qualifyPath(library: string, object: string, member: string, iasp?: string): string;
+    /**
+     * @param Path
+     * @returns the escaped path
+     */
+    function escapePath(Path: string): string;
+}

package/extension.d.ts

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

package/instantiate.d.ts

@@ -0,0 +1,14 @@
+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 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,10 +1,11 @@
 {
   "name": "@halcyontech/vscode-ibmi-types",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Types for vscode-ibmi",
   "typings": "./typings.d.ts",
   "scripts": {
-    "prepublish": "rm -rf filesystems schemas views webviews languages"
+    "prepublish": "rm -rf filesystems schemas views webviews languages",
+    "deploy": "npm publish --access public"
   },
   "repository": {
     "url": "https://github.com/halcyon-tech/vscode-ibmi"

package/readme.md

@@ -2,12 +2,12 @@
 
 Type definitions for working with the Code for IBM i API.
 
-Install from this repository with `npm i halcyon-tech/vscode-ibmi-types`.
+Install the types with `npm i npm i @halcyontech/vscode-ibmi-types`.
 
 Use in your extension:
 
 ```ts
-import {CodeForIBMi} from 'vscode-ibmi-types';
+import {CodeForIBMi} from '@halcyontech/vscode-ibmi-types';
 
 //...
 

package/typings.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="node" />
+import { ExtensionContext } from "vscode";
+import Instance from "./api/Instance";
+export interface CodeForIBMi {
+    instance: Instance;
+    baseContext: ExtensionContext;
+    CustomUI: object;
+    Field: object;
+}
+export interface StandardIO {
+    onStdout?: (data: Buffer) => void;
+    onStderr?: (data: Buffer) => void;
+    stdin?: string;
+}
+/**
+ * External interface for extensions to call `code-for-ibmi.runCommand`
+ */
+export interface RemoteCommand {
+    command: string;
+    environment?: "ile" | "qsh" | "pase";
+    cwd?: string;
+    env?: {
+        [name: string]: string;
+    };
+}
+export interface CommandData extends StandardIO {
+    command: string;
+    directory?: string;
+    env?: {
+        [name: string]: string;
+    };
+}
+export interface CommandResult {
+    code: number | null;
+    stdout: string;
+    stderr: string;
+    command?: string;
+}
+export interface Action {
+    name: string;
+    command: string;
+    type?: "member" | "streamfile" | "object" | "file";
+    environment: "ile" | "qsh" | "pase";
+    extensions: string[];
+    deployFirst?: boolean;
+    postDownload?: string[];
+}
+export interface ConnectionData {
+    name: string;
+    host: string;
+    port: number;
+    username: string;
+    password?: string;
+    privateKey: string | null;
+    keepaliveInterval: number;
+}
+export interface Server {
+    name: string;
+}
+export interface Profile {
+    profile: string;
+}
+export interface IBMiObject {
+    library: string;
+    name: string;
+    type: string;
+    text: string;
+    attribute?: string;
+}