jspm

  • Version 2.0.0-beta.7
  • Published
  • 759 kB
  • 32 dependencies
  • Apache-2.0 license

Install

npm i jspm
yarn add jspm
pnpm add jspm

Overview

Universal ES Module Package Manager

Index

Variables

variable exec

const exec: (args?: any[], projectPath?: string) => Promise<number>;

    variable JSPM_GLOBAL_PATH

    const JSPM_GLOBAL_PATH: string;

      variable run

      const run: (target: string, args: string[], opts: JspxOptions) => Promise<number>;

        variable version

        const version: any;

          Functions

          function build

          build: (
          input: string[] | Record<string, string>,
          opts: BuildOptions
          ) => Promise<ImportMap>;

            function filterMap

            filterMap: (
            project: Project,
            map: ImportMap,
            modules: string[],
            flatScope?: boolean
            ) => Promise<ImportMap>;

              function map

              map: (project: Project, env: any) => Promise<ImportMap>;

                function renormalizeMap

                renormalizeMap: (
                map: ImportMap,
                jspmPackagesURL: string,
                cdn: boolean
                ) => ImportMap;

                  function resolve

                  resolve: (
                  name: string,
                  parent?: string,
                  env?: any,
                  relativeFallback?: boolean
                  ) => Promise<any>;

                    function resolveSync

                    resolveSync: (
                    name: string,
                    parent?: string,
                    env?: any,
                    relativeFallback?: boolean
                    ) => any;

                      function runHook

                      runHook: (project: Project, name: Hook) => Promise<void>;

                        function trace

                        trace: (
                        project: Project,
                        map: ImportMap,
                        baseDir: string,
                        modules: string[],
                        excludeDeps?: boolean
                        ) => Promise<Record<string, Record<string, string>>>;

                          Classes

                          class Project

                          class Project {}

                            constructor

                            constructor(projectPath: string, options: ProjectConfiguration);

                              property cacheDir

                              cacheDir: string;

                                property checkedGlobalBin

                                checkedGlobalBin: boolean;

                                  property cli

                                  cli: boolean;

                                    property config

                                    config: Config;

                                      property confirm

                                      confirm: (
                                      msg: string,
                                      def?: string | boolean | ConfirmOptions,
                                      options?: ConfirmOptions
                                      ) => Promise<boolean>;

                                        property defaultRegistry

                                        defaultRegistry: string;

                                          property fetch

                                          fetch: FetchClass;

                                            property globalConfig

                                            globalConfig: GlobalConfig;

                                              property input

                                              input: (
                                              msg: string,
                                              def: string | InputOptions,
                                              options?: InputOptions,
                                              queue?: boolean
                                              ) => Promise<string>;

                                                property installer

                                                installer: Installer;

                                                  property log

                                                  log: Logger;

                                                    property offline

                                                    offline: boolean;

                                                      property preferOffline

                                                      preferOffline: boolean;

                                                        property projectPath

                                                        projectPath: string;

                                                          property registryManager

                                                          registryManager: RegistryManager;

                                                            property userInput

                                                            userInput: boolean;

                                                              method checkGlobalBin

                                                              checkGlobalBin: () => void;

                                                                method checkout

                                                                checkout: (names: string[]) => Promise<void>;

                                                                  method clean

                                                                  clean: () => Promise<void>;

                                                                    method clearCache

                                                                    clearCache: () => Promise<void>;

                                                                      method dispose

                                                                      dispose: () => Promise<[void, void[], void]>;

                                                                        method init

                                                                        init: (basePath: string) => Promise<void>;

                                                                          method install

                                                                          install: (installs: Install[], opts?: InstallOptions) => Promise<void>;
                                                                            link: (pkg: string, source: string, opts: InstallOptions) => Promise<void>;

                                                                              method registryConfig

                                                                              registryConfig: (name: string) => Promise<void>;

                                                                                method run

                                                                                run: (name: string, args: string[]) => Promise<number>;

                                                                                  method save

                                                                                  save: () => Promise<boolean>;

                                                                                    method uninstall

                                                                                    uninstall: (names: string[]) => Promise<void>;

                                                                                      method update

                                                                                      update: (selectors: string[], opts: InstallOptions) => Promise<void>;

                                                                                        Interfaces

                                                                                        interface Logger

                                                                                        interface Logger {}

                                                                                          property debug

                                                                                          debug: (msg: string) => void;

                                                                                            property err

                                                                                            err: (err: string | Error | JspmUserError) => void;

                                                                                              property errMsg

                                                                                              errMsg: (err: string | Error | JspmUserError) => void;

                                                                                                property info

                                                                                                info: (msg: string) => void;

                                                                                                  property msg

                                                                                                  msg: (msg: string) => void;

                                                                                                    property newline

                                                                                                    newline: () => void;

                                                                                                      property ok

                                                                                                      ok: (msg: string) => void;

                                                                                                        property taskEnd

                                                                                                        taskEnd: (name: string) => void;

                                                                                                          property taskStart

                                                                                                          taskStart: (name: string) => () => void;

                                                                                                            property warn

                                                                                                            warn: (msg: string) => void;

                                                                                                              interface ProjectConfiguration

                                                                                                              interface ProjectConfiguration {}

                                                                                                                property cacheDir

                                                                                                                cacheDir?: string;

                                                                                                                  property cli

                                                                                                                  cli?: boolean;

                                                                                                                    property defaultRegistry

                                                                                                                    defaultRegistry?: string;

                                                                                                                      property offline

                                                                                                                      offline?: boolean;

                                                                                                                        property preferOffline

                                                                                                                        preferOffline?: boolean;

                                                                                                                          property registries

                                                                                                                          registries?: {
                                                                                                                          [name: string]: Registry;
                                                                                                                          };

                                                                                                                            property strictSSL

                                                                                                                            strictSSL?: boolean;

                                                                                                                              property timeouts

                                                                                                                              timeouts?: {
                                                                                                                              resolve?: number;
                                                                                                                              download?: number;
                                                                                                                              };

                                                                                                                                property userInput

                                                                                                                                userInput?: boolean;

                                                                                                                                  Type Aliases

                                                                                                                                  type confirm

                                                                                                                                  type confirm = typeof confirm;

                                                                                                                                    type Hook

                                                                                                                                    type Hook = 'preinstall' | 'postinstall';

                                                                                                                                      type input

                                                                                                                                      type input = typeof input;

                                                                                                                                        Package Files (4)

                                                                                                                                        Dependencies (32)

                                                                                                                                        Dev Dependencies (4)

                                                                                                                                        Peer Dependencies (0)

                                                                                                                                        No peer dependencies.

                                                                                                                                        Badge

                                                                                                                                        To add a badge like this onejsDocs.io badgeto your package's README, use the codes available below.

                                                                                                                                        You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/jspm.

                                                                                                                                        • Markdown
                                                                                                                                          [![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/jspm)
                                                                                                                                        • HTML
                                                                                                                                          <a href="https://www.jsdocs.io/package/jspm"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>