vbapm 0.6.3-alpha

package/lib/src/actions/build-project.d.ts

@@ -0,0 +1,2 @@
+import { BuildOptions } from "../targets/build-target";
+export declare function buildProject(options?: BuildOptions): Promise<string>;

package/lib/src/actions/create-project.d.ts

@@ -0,0 +1,8 @@
+export interface CreateOptions {
+    name: string;
+    target?: string;
+    from?: string;
+    pkg: boolean;
+    git: boolean;
+}
+export declare function createProject(options: CreateOptions): Promise<void>;

package/lib/src/actions/export-project.d.ts

@@ -0,0 +1,6 @@
+export interface ExportOptions {
+    target?: string;
+    completed?: string;
+    addin?: string;
+}
+export declare function exportProject(options?: ExportOptions): Promise<void>;

package/lib/src/actions/increment-version.d.ts

@@ -0,0 +1,5 @@
+interface IncrementVersionOptions {
+    preid?: string;
+}
+export declare function incrementVersion(increment: string, options?: IncrementVersionOptions): Promise<string>;
+export {};

package/lib/src/actions/init-project.d.ts

@@ -0,0 +1,9 @@
+export interface InitOptions {
+    name?: string;
+    dir?: string;
+    target?: string;
+    from?: string;
+    pkg: boolean;
+    git: boolean;
+}
+export declare function initProject(options: InitOptions): Promise<void>;

package/lib/src/actions/run-macro.d.ts

@@ -0,0 +1,8 @@
+import { RunResult } from "../utils/run";
+export interface RunOptions {
+    target?: string;
+    file?: string;
+    macro: string;
+    args: string[];
+}
+export declare function runMacro(options: RunOptions): Promise<RunResult>;

package/lib/src/actions/test-project.d.ts

@@ -0,0 +1,5 @@
+export interface TestOptions {
+    target?: string;
+    args: string[];
+}
+export declare function testProject(options: TestOptions): Promise<void>;

package/lib/src/addin.d.ts

@@ -0,0 +1,36 @@
+import { ImportGraph } from "./build/build-graph";
+import { Target } from "./manifest/target";
+import { Project } from "./project";
+export type Application = "excel";
+export type Addin = string;
+export interface AddinOptions {
+    addin?: string;
+    staging?: boolean;
+}
+export declare const extensions: {
+    [application: string]: string[];
+};
+export declare const addins: {
+    [application: string]: string;
+};
+/**
+ * Import graph of src and references into given target
+ */
+export declare function importGraph(project: Project, target: Target, graph: ImportGraph, file: string, options?: AddinOptions): Promise<void>;
+/**
+ * Export src and references from given target
+ */
+export declare function exportTo(project: Project, target: Target, staging: string, options?: AddinOptions): Promise<void>;
+/**
+ * Create a new document at the given path
+ */
+export declare function createDocument(project: Project, target: Target, options?: AddinOptions): Promise<string>;
+/**
+ * Get application, addin, and file for given target
+ */
+export declare function getTargetInfo(project: Project, target: Target, options?: AddinOptions): {
+    application: Application;
+    addin: Addin;
+    file: string;
+};
+export declare function extensionToApplication(extension: string): Application;

package/lib/src/bin/vba-blocks-build.d.ts

@@ -0,0 +1,2 @@
+import { Args } from "mri";
+export default function (args: Args): Promise<void>;

package/lib/src/bin/vba-blocks-export.d.ts

@@ -0,0 +1,2 @@
+import { Args } from "mri";
+export default function (args: Args): Promise<void>;

package/lib/src/bin/vba-blocks-init.d.ts

@@ -0,0 +1,2 @@
+import { Args } from "mri";
+export default function (args: Args): Promise<void>;

package/lib/src/bin/vba-blocks-new.d.ts

@@ -0,0 +1,2 @@
+import { Args } from "mri";
+export default function (args: Args): Promise<void>;

package/lib/src/bin/vba-blocks-run.d.ts

@@ -0,0 +1,2 @@
+import { Args } from "mri";
+export default function (args: Args): Promise<void>;

package/lib/src/bin/vba-blocks-test.d.ts

@@ -0,0 +1,2 @@
+import { Args } from "mri";
+export default function (args: Args): Promise<void>;

package/lib/src/bin/vba-blocks-version.d.ts

@@ -0,0 +1,2 @@
+import { Args } from "mri";
+export default function (args: Args): Promise<void>;

package/lib/src/bin/vba-blocks.d.ts

@@ -0,0 +1,2 @@
+import { CliError } from "../errors";
+export declare function handleError(err: Error | CliError | any, _promise?: Promise<any>): void;

package/lib/src/build/apply-changeset.d.ts

@@ -0,0 +1,3 @@
+import { Project } from "../project";
+import { Changeset } from "./changeset";
+export declare function applyChangeset(project: Project, changeset: Changeset): Promise<void>;

package/lib/src/build/build-graph.d.ts

@@ -0,0 +1,18 @@
+import { Reference } from "../manifest/reference";
+import { Source } from "../manifest/source";
+import { Component } from "./component";
+export interface FromDependences {
+    components: Map<Component, string>;
+    references: Map<Reference, string>;
+}
+export interface BuildGraph {
+    name: string;
+    components: Component[];
+    references: Reference[];
+    fromDependencies: FromDependences;
+}
+export interface ImportGraph {
+    name: string;
+    components: Source[];
+    references: Reference[];
+}

package/lib/src/build/changeset.d.ts

@@ -0,0 +1,14 @@
+import { Reference } from "../manifest/reference";
+import { Component } from "./component";
+export interface Changeset {
+    components: {
+        added: Component[];
+        changed: Component[];
+        removed: Component[];
+    };
+    references: {
+        added: Reference[];
+        changed: Reference[];
+        removed: Reference[];
+    };
+}

package/lib/src/build/compare-build-graphs.d.ts

@@ -0,0 +1,3 @@
+import { BuildGraph } from "./build-graph";
+import { Changeset } from "./changeset";
+export declare function compareBuildGraphs(before: BuildGraph, after: BuildGraph): Changeset;

package/lib/src/build/component.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+export type ComponentType = "module" | "class" | "form" | "document";
+export interface ComponentDetails {
+    path?: string;
+    binary?: Buffer;
+}
+export declare class Component {
+    type: ComponentType;
+    code: string;
+    details: ComponentDetails;
+    constructor(type: ComponentType, code: Buffer | string, details?: ComponentDetails);
+    get name(): string;
+    get binaryPath(): string | undefined;
+    get filename(): string;
+    static load(path: string, details?: {
+        binary_path?: string;
+    }): Promise<Component>;
+}
+export declare const extensionToType: {
+    [extension: string]: ComponentType;
+};
+export declare const typeToExtension: {
+    [type: string]: string;
+};
+export declare function byComponentName(a: Component, b: Component): number;

package/lib/src/build/index.d.ts

@@ -0,0 +1,7 @@
+export { applyChangeset } from "./apply-changeset";
+export { compareBuildGraphs } from "./compare-build-graphs";
+export { Component } from "./component";
+export { loadFromExport } from "./load-from-export";
+export { loadFromProject } from "./load-from-project";
+export { stageBuildGraph } from "./stage-build-graph";
+export { toCompiled, toSrc } from "./transform-build-graph";

package/lib/src/build/load-from-export.d.ts

@@ -0,0 +1,2 @@
+import { BuildGraph } from "./build-graph";
+export declare function loadFromExport(staging: string): Promise<BuildGraph>;

package/lib/src/build/load-from-project.d.ts

@@ -0,0 +1,5 @@
+import { Manifest } from "../manifest";
+import { Project } from "../project";
+import { BuildOptions } from "../targets/build-target";
+import { BuildGraph } from "./build-graph";
+export declare function loadFromProject(project: Project, dependencies: Manifest[], options?: BuildOptions): Promise<BuildGraph>;

package/lib/src/build/stage-build-graph.d.ts

@@ -0,0 +1,2 @@
+import { BuildGraph, ImportGraph } from "./build-graph";
+export declare function stageBuildGraph(graph: BuildGraph, staging: string): Promise<ImportGraph>;

package/lib/src/build/transform-build-graph.d.ts

@@ -0,0 +1,3 @@
+import { BuildGraph } from "./build-graph";
+export declare const toCompiled: (input: BuildGraph) => Promise<BuildGraph>;
+export declare const toSrc: (input: BuildGraph) => Promise<BuildGraph>;

package/lib/src/build/transforms/editor-config.d.ts

@@ -0,0 +1,3 @@
+import { BuildGraph } from "../build-graph";
+export declare function toCompiled(graph: BuildGraph): Promise<BuildGraph>;
+export declare function toSrc(graph: BuildGraph): Promise<BuildGraph>;

package/lib/src/cache.d.ts

@@ -0,0 +1,9 @@
+import Conf from "conf";
+export declare class Cache extends Conf {
+    constructor(cwd?: string);
+    get latest_version(): string | undefined;
+    set latest_version(version: string | undefined);
+    get latest_version_checked(): number | undefined;
+    set latest_version_checked(timestamp: number | undefined);
+}
+export declare const cache: Cache;

package/lib/src/config.d.ts

@@ -0,0 +1,29 @@
+import { Sources } from "./sources";
+export type Registry = {} | {
+    [name: string]: {
+        index: string;
+        packages: string;
+    };
+};
+export interface Flags {
+}
+export interface Config {
+    registry: Registry;
+    flags: Flags;
+    sources: Sources;
+}
+export interface ConfigValue {
+    registry?: Registry;
+    flags?: Flags;
+}
+/**
+ * Load config, from local, user, and environment values
+ *
+ * - env:config/config.toml (user)
+ * - Search for .vba-blocks/config.toml up from cwd (local)
+ * - Load VBA_BLOCKS_* from environment (override)
+ */
+export declare function loadConfig(): Promise<Config>;
+export declare function readConfig(dir: string): Promise<ConfigValue | undefined>;
+export declare function findConfig(dir: string): Promise<string | undefined>;
+export declare function loadConfigFromEnv(): ConfigValue;

package/lib/src/debug.d.ts

@@ -0,0 +1,2 @@
+import debug from "debug";
+export default debug;

package/lib/src/env.d.ts

@@ -0,0 +1,21 @@
+import { Reporter } from "./reporter";
+export interface Env {
+    isWindows: boolean;
+    cwd: string;
+    values: any;
+    data: string;
+    config: string;
+    cache: string;
+    log: string;
+    temp: string;
+    addins: string;
+    scripts: string;
+    registry: string;
+    packages: string;
+    sources: string;
+    staging: string;
+    reporter: Reporter;
+    debug: (id: string) => (...values: any[]) => void;
+    silent: boolean;
+}
+export declare const env: Env;

package/lib/src/errors.d.ts

@@ -0,0 +1,56 @@
+export declare class CliError extends Error {
+    code: ErrorCode;
+    underlying?: Error;
+    constructor(code: ErrorCode, message: string, underlying?: Error);
+}
+export declare function isCliError(error: Error | CliError): error is CliError;
+export declare enum ErrorCode {
+    Unknown = "unknown",
+    UnknownCommand = "unknown-command",
+    ManifestNotFound = "manifest-not-found",
+    ManifestInvalid = "manifest-invalid",
+    SourceUnsupported = "source-unsupported",
+    SourceMisconfiguredRegistry = "source-misconfigured-registry",
+    SourceNoneMatching = "source-none-matching",
+    SourceDownloadFailed = "source-download-failed",
+    SourceUnrecognizedType = "source-unrecognized-type",
+    DependencyNotFound = "dependency-not-found",
+    DependencyInvalidChecksum = "dependency-invalid-checksum",
+    DependencyPathNotFound = "dependency-path-not-found",
+    DependencyUnknownSource = "dependency-unknown-source",
+    BuildInvalid = "build-invalid",
+    LockfileWriteFailed = "lockfile-write-failed",
+    TargetNoMatching = "target-no-matching",
+    TargetNoDefault = "target-no-default",
+    TargetNotFound = "target-not-found",
+    TargetIsOpen = "target-is-open",
+    TargetCreateFailed = "target-create-failed",
+    TargetImportFailed = "target-import-failed",
+    TargetRestoreFailed = "target-restore-failed",
+    TargetAddNoType = "target-add-no-type",
+    TargetAlreadyDefined = "target-already-defined",
+    ResolveFailed = "resolve-failed",
+    ComponentUnrecognized = "component-unrecognized",
+    ComponentInvalidNoName = "component-invalid-no-name",
+    RunScriptNotFound = "run-script-not-found",
+    NewNameRequired = "new-name-required",
+    NewTargetRequired = "new-target-required",
+    NewDirExists = "new-dir-exists",
+    FromNotFound = "from-not-found",
+    InitAlreadyInitialized = "init-already-initialized",
+    InitNameRequired = "init-name-required",
+    InitTargetRequired = "init-target-required",
+    ExportNoTarget = "export-no-target",
+    ExportNoMatching = "export-no-matching",
+    ExportTargetNotFound = "export-target-not-found",
+    AddinUnsupportedType = "addin-unsupported-type",
+    RunMissingFile = "run-missing-file",
+    RunMissingMacro = "run-missing-macro",
+    RegistryCloneFailed = "registry-clone-failed",
+    InvalidVersion = "invalid-version"
+}
+export declare function manifestOk(value: any, message: string): void;
+export declare function cleanError(error: string | Error): {
+    message: string;
+    stack: string;
+};

package/lib/src/index.d.ts

@@ -0,0 +1,16 @@
+export { buildProject } from "./actions/build-project";
+export { createProject } from "./actions/create-project";
+export { exportProject } from "./actions/export-project";
+export { initProject } from "./actions/init-project";
+export { runMacro } from "./actions/run-macro";
+export { testProject } from "./actions/test-project";
+export { addins } from "./addin";
+export { loadConfig } from "./config";
+export { env } from "./env";
+export { parseManifest } from "./manifest";
+export { loadWorkspace } from "./professional/workspace";
+export { fetchDependencies, loadProject } from "./project";
+export { default as resolveDependencies } from "./resolve";
+export { fetch as fetchDependency, resolve as resolveDependency } from "./sources";
+export { checksum } from "./utils/fs";
+export { run } from "./utils/run";

package/lib/src/installer.d.ts

@@ -0,0 +1,3 @@
+export declare function updateVersion(): string | undefined;
+export declare function updateAvailable(): boolean;
+export declare function checkForUpdate(): Promise<boolean>;

package/lib/src/lockfile/index.d.ts

@@ -0,0 +1,23 @@
+import { Project } from "../project.js";
+import { Lockfile } from "./lockfile";
+export { default as isLockfileValid } from "./is-lockfile-valid";
+/**
+ * Read lockfile at given dir (if present)
+ * (for invalid lockfile, errors are ignored and treated as no lockfile)
+ */
+export declare function readLockfile(dir: string): Promise<Lockfile | null>;
+/**
+ * Write lockfile for project to given dir
+ *
+ * @throws LockfileWriteFailed
+ */
+export declare function writeLockfile(dir: string, project: Project): Promise<void>;
+/**
+ * Convert project to lockfile toml, alphabetized and with trailing commas
+ * (should be suitable for VCS)
+ */
+export declare function toToml(project: Project, dir: string): string;
+/**
+ * Load lockfile from toml (including "hydrating" dependencies from packages)
+ */
+export declare function fromToml(toml: string, dir: string): Promise<Lockfile>;

package/lib/src/lockfile/is-lockfile-valid.d.ts

@@ -0,0 +1,10 @@
+import { Workspace } from "../professional/workspace";
+import { Lockfile } from "./lockfile";
+/**
+ * ## Is lockfile valid?
+ *
+ * - [ ] Lockfile version has not changed
+ * - [ ] Workspace root manifest has not changed
+ * - [ ] Workspace members have not changed
+ */
+export default function isLockfileValid(lockfile: Lockfile, workspace: Workspace): Promise<boolean>;

package/lib/src/lockfile/lockfile.d.ts

@@ -0,0 +1,26 @@
+import { Dependency } from "../manifest/dependency";
+import { DependencyGraph } from "../resolve/dependency-graph";
+export interface MinimalSnapshot {
+    name: string;
+    dependencies: Dependency[];
+}
+export declare const LOCKFILE_VERSION = "1";
+/**
+ * ## Lockfile
+ *
+ * Save resolved dependency graph and workspace information
+ * for precisely rebuilding dependency graph if the workspace hasn't changed
+ *
+ * Version the lockfile separately from vba-blocks to allow the lockfile format to change over time,
+ * while staying isolated from the more-frequent changes to the vba-blocks version.
+ */
+export interface Lockfile {
+    metadata?: {
+        version: string;
+    };
+    workspace: {
+        root: MinimalSnapshot;
+        members: MinimalSnapshot[];
+    };
+    packages: DependencyGraph;
+}

package/lib/src/manifest/dependency.d.ts

@@ -0,0 +1,25 @@
+import { Version } from "./version";
+export interface DependencyDetails {
+    name: string;
+    version?: Version;
+}
+export interface RegistryDependency extends DependencyDetails {
+    registry: string;
+    version: Version;
+}
+export interface PathDependency extends DependencyDetails {
+    path: string;
+}
+export interface GitDependency extends DependencyDetails {
+    git: string;
+    tag?: string;
+    branch?: string;
+    rev?: string;
+}
+export type Dependency = RegistryDependency | PathDependency | GitDependency;
+export declare function parseDependencies(value: any, dir: string): Dependency[];
+export declare function parseDependency(name: string, value: Version | any, dir: string): Dependency;
+export declare function isRegistryDependency(dependency: Dependency): dependency is RegistryDependency;
+export declare function isPathDependency(dependency: Dependency): dependency is PathDependency;
+export declare function isGitDependency(dependency: Dependency): dependency is GitDependency;
+export declare function formatDependencies(dependencies: Dependency[], dir: string): object;

package/lib/src/manifest/index.d.ts

@@ -0,0 +1,34 @@
+import { Dependency } from "./dependency";
+import { Reference } from "./reference";
+import { Source } from "./source";
+import { Target } from "./target";
+import { Version } from "./version";
+/**
+ * Snapshot is the minimal manifest needed to support both Manifest
+ * and info loaded during dependency resolution
+ */
+export interface Snapshot {
+    name: string;
+    version: Version;
+    dependencies: Dependency[];
+}
+export type ManifestType = "package" | "project";
+export interface Metadata {
+    authors?: string[];
+    publish?: boolean;
+    [name: string]: any;
+}
+export interface Manifest extends Snapshot {
+    type: ManifestType;
+    metadata: Metadata;
+    src: Source[];
+    references: Reference[];
+    devSrc: Source[];
+    devDependencies: Dependency[];
+    devReferences: Reference[];
+    target?: Target;
+}
+export declare function parseManifest(value: any, dir: string): Manifest;
+export declare function loadManifest(dir: string): Promise<Manifest>;
+export declare function writeManifest(manifest: Manifest, dir: string): Promise<void>;
+export declare function formatManifest(manifest: Manifest, dir: string): object;

package/lib/src/manifest/reference.d.ts

@@ -0,0 +1,12 @@
+export interface ReferenceDetails {
+    dependency?: string;
+}
+export interface Reference {
+    name: string;
+    guid: string;
+    major: number;
+    minor: number;
+}
+export declare function parseReferences(value: any): Reference[];
+export declare function parseReference(name: string, value: any): Reference;
+export declare function formatReferences(references: Reference[]): object;

package/lib/src/manifest/source.d.ts

@@ -0,0 +1,8 @@
+export interface Source {
+    name: string;
+    path: string;
+    binary?: string;
+}
+export declare function parseSrc(value: any, dir: string): Source[];
+export declare function parseSource(name: string, value: string | any, dir: string): Source;
+export declare function formatSrc(src: Source[], dir: string): object;

package/lib/src/manifest/target.d.ts

@@ -0,0 +1,10 @@
+export type TargetType = "xlsx" | "xlsm" | "xlam";
+export interface Target {
+    name: string;
+    type: TargetType;
+    path: string;
+    filename: string;
+}
+export declare function parseTarget(value: any, pkgName: string, dir: string): Target;
+export declare function isSupportedTargetType(type: string): type is TargetType;
+export declare function formatTarget(target: Target, defaultName: string, dir: string): string | object;

package/lib/src/manifest/version.d.ts

@@ -0,0 +1,3 @@
+export type Version = string;
+export declare const DEFAULT_VERSION = "UNVERSIONED";
+export declare function isValid(value: string): value is Version;

package/lib/src/messages.d.ts

@@ -0,0 +1,22 @@
+export declare enum Message {
+    UpdateAvailable = "update-available",
+    BuildProjectLoading = "build-project-loading",
+    BuildTargetBuilding = "build-target-building",
+    BuildLockfileWriting = "build-lockfile-writing",
+    ExportProjectLoading = "export-project-loading",
+    ExportToStaging = "export-to-staging",
+    ExportToProject = "export-to-project",
+    ProjectUpdating = "project-updating",
+    DependenciesResolving = "dependencies-resolving",
+    DependenciesFetching = "dependencies-fetching",
+    ExportLoading = "export-loading",
+    PatchApplyChanges = "patch-apply-changes",
+    PatchAddSrc = "patch-add-src",
+    PatchRemoveSrc = "patch-remove-src",
+    PatchAddDependency = "patch-add-dependency",
+    PatchRemoveDependency = "patch-remove-dependency",
+    PatchAddReference = "patch-add-reference",
+    PatchRemoveReference = "patch-remove-reference",
+    RegistrySourceLocalOnly = "registry-source-local-only",
+    RegistrySourceSkipPull = "registry-source-skip-pull"
+}

package/lib/src/professional/sources/git-source.d.ts

@@ -0,0 +1,7 @@
+import { Dependency } from "../../manifest/dependency";
+import { Registration } from "../../sources/registration";
+import { Source } from "../../sources/source";
+export declare class GitSource implements Source {
+    resolve(_dependency: Dependency): Registration[];
+    fetch(_registration: Registration): string;
+}

package/lib/src/professional/workspace.d.ts

@@ -0,0 +1,10 @@
+import { Manifest } from "../manifest";
+export interface Workspace {
+    paths: {
+        root: string;
+        members: string[];
+    };
+    root: Manifest;
+    members: Manifest[];
+}
+export declare function loadWorkspace(manifest: Manifest, dir: string): Promise<Workspace>;

package/lib/src/project.d.ts

@@ -0,0 +1,48 @@
+import { Config } from "./config";
+import { Manifest } from "./manifest";
+import { Workspace } from "./professional/workspace";
+import { DependencyGraph } from "./resolve/dependency-graph";
+export interface Project {
+    manifest: Manifest;
+    workspace: Workspace;
+    packages: DependencyGraph;
+    config: Config;
+    paths: {
+        root: string;
+        dir: string;
+        build: string;
+        backup: string;
+        staging: string;
+    };
+    hasDirtyLockfile: boolean;
+}
+/**
+ * Load project from given directory / cwd
+ *
+ * 1. Load manifest in dir
+ * 2. Load workspace from manifest
+ * 3. Load lockfile
+ * 4. Resolve dependencies
+ */
+export declare function loadProject(dir?: string): Promise<Project>;
+export interface FetchProject {
+    manifest: Manifest;
+    packages: DependencyGraph;
+    config: Config;
+}
+/**
+ * Fetch all dependencies for project
+ * (based on already resolved project.packages)
+ *
+ * After sources complete fetches, manifests are loaded and returned for each package
+ */
+export declare function fetchDependencies(project: FetchProject): Promise<Manifest[]>;
+export interface ProjectOptions {
+    type?: "project" | "package";
+}
+/**
+ * Initialize new project
+ *
+ * Minimum requirements: name and dir
+ */
+export declare function initProject(name: string, dir: string, options?: ProjectOptions): Promise<Project>;