@halcyontech/vscode-ibmi-types 1.6.1 → 1.6.8

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,84 @@
+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;
+    uploadFiles(files: {
+        local: string | vscode.Uri;
+        remote: string;
+    }[], options?: node_ssh.SSHPutFilesOptions): Promise<void>;
+    downloadFile(localFile: string | vscode.Uri, remoteFile: string): Promise<void>;
+    uploadDirectory(localDirectory: string | vscode.Uri, remoteDirectory: string, options?: node_ssh.SSHGetPutDirectoryOptions): Promise<void>;
+    downloadDirectory(localDirectory: string | vscode.Uri, remoteDirectory: string, options?: node_ssh.SSHGetPutDirectoryOptions): Promise<void>;
+    fileToPath(file: string | vscode.Uri): string;
+}
+export {};

package/api/IBMiContent.d.ts

@@ -0,0 +1,69 @@
+import { default as IBMi } from './IBMi';
+import { Tools } from './Tools';
+import { IBMiError, IBMiFile, IBMiMember, IBMiObject, IFSFile } from '../typings';
+export default class IBMiContent {
+    readonly ibmi: IBMi;
+    constructor(ibmi: IBMi);
+    private get config();
+    private getTempRemote;
+    private getNotUTF8CCSID;
+    private convertToUTF8;
+    downloadStreamfile(remotePath: string, localPath?: string): Promise<string>;
+    writeStreamfile(originalPath: any, content: any): Promise<string | void>;
+    /**
+     * Download the contents of a source member
+     */
+    downloadMemberContent(asp: string | undefined, library: string, sourceFile: string, member: string): Promise<string>;
+    /**
+     * Upload to a member
+     */
+    uploadMemberContent(asp: string | undefined, library: string, sourceFile: string, member: string, content: string | Uint8Array): Promise<boolean>;
+    /**
+     * Run an SQL statement
+     * @param statement
+     * @returns a Result set
+     */
+    runSQL(statement: string): Promise<Tools.DB2Row[]>;
+    /**
+     * Download the contents of a table.
+     * @param library
+     * @param file
+     * @param member Will default to file provided
+     * @param deleteTable Will delete the table after download
+     */
+    getTable(library: string, file: string, member: string, deleteTable: boolean): Promise<Tools.DB2Row[]>;
+    /**
+     * Get list of libraries with description and attribute
+     * @param libraries Array of libraries to retrieve
+     * @returns an array of libraries as IBMiObject
+     */
+    getLibraryList(libraries: string[]): Promise<IBMiObject[]>;
+    /**
+     * @param filters
+     * @param sortOrder
+     * @returns an array of IBMiFile
+     */
+    getObjectList(filters: {
+        library: string;
+        object?: string;
+        types?: string[];
+    }, sortOrder?: `name` | `type`): Promise<IBMiFile[]>;
+    /**
+     * @param lib
+     * @param spf
+     * @param mbr
+     * @returns an array of IBMiMember
+     */
+    getMemberList(lib: string, spf: string, mbr?: string, ext?: string): Promise<IBMiMember[]>;
+    /**
+     * Get list of items in a path
+     * @param remotePath
+     * @return an array of IFSFile
+     */
+    getFileList(remotePath: string): Promise<IFSFile[]>;
+    /**
+     * @param errorsString; several lines of `code:text`...
+     * @returns errors
+     */
+    parseIBMiErrors(errorsString: string): IBMiError[];
+}

package/api/Instance.d.ts

@@ -0,0 +1,22 @@
+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;
+    onEvent(event: "connected", func: Function): void;
+}

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,11 +1,11 @@
 {
   "name": "@halcyontech/vscode-ibmi-types",
-  "version": "1.6.1",
+  "version": "1.6.8",
   "description": "Types for vscode-ibmi",
   "typings": "./typings.d.ts",
   "scripts": {
     "prepublish": "rm -rf filesystems schemas views webviews languages",
-    "publish": "npm publish --access public"
+    "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,90 @@
+/// <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;
+}
+export interface IBMiFile extends IBMiObject {
+    count?: number;
+}
+export interface IBMiMember {
+    library: string;
+    file: string;
+    name: string;
+    extension: string;
+    recordLength: number;
+    text: string;
+    asp?: string;
+}
+export interface IFSFile {
+    type: "directory" | "streamfile";
+    name: string;
+    path: string;
+}
+export interface IBMiError {
+    code: string;
+    text: string;
+}