• Version 0.3.4
  • Published
  • 9 dependencies
  • MIT license


npm i jspm-config
yarn add jspm-config
pnpm add jspm-config


Read jspm config and such



function readDependenciesJson

readDependenciesJson: (
jspmPackageJson: JspmPackageJson,
options: Options
) => Promise<DependenciesJson>;

    function readJspmConfigs

    readJspmConfigs: (
    jspmPackageJson: JspmPackageJson,
    options: Options
    ) => Promise<Configs>;

      function readJspmPackageJson

      readJspmPackageJson: (options: Options) => Promise<JspmPackageJson>;

        function readProjectConfig

        readProjectConfig: (options: Options) => Promise<JspmProjectInfo>;

          function resolve

          resolve: (moduleName: string, options: Options) => Promise<DependencyTree>;

            function resolveAll

            resolveAll: (options: Options) => Promise<DependencyBranch>;

              function resolveByPackageJson

              resolveByPackageJson: (
              pjson: JspmPackageJson,
              options: Options
              ) => Promise<DependencyBranch>;


                class ConfigError

                class ConfigError extends BaseError {}
                • This error signifies there are issue with the jspm configuration.

                class ModuleNotFoundError

                class ModuleNotFoundError extends BaseError {}
                • This error signifies the module requested is not found.


                constructor(moduleName: string);


                  interface ConfigFiles

                  interface ConfigFiles {}

                    property 'jspm:browser'

                    'jspm:browser': string;

                      property 'jspm:dev'

                      'jspm:dev': string;

                        property 'jspm:node'

                        'jspm:node': string;

                          property jspm

                          jspm: string;

                            interface Configs

                            interface Configs {}

                              property browser

                              browser?: any;

                                property dev

                                dev?: any;

                                  property jspm

                                  jspm?: any;

                                    property node

                                    node?: any;

                                      interface DependenciesJson

                                      interface DependenciesJson {}
                                      • Interface for <jspm_packages>/.dependencies.json.

                                      index signature

                                      [index: string]: {
                                      deps: {
                                      [index: string]: string;
                                      peerDeps: {
                                      [index: string]: string;

                                        interface DependencyBranch

                                        interface DependencyBranch {}

                                          index signature

                                          [moduleName: string]: DependencyTree;

                                            interface DependencyInfo

                                            interface DependencyInfo {}

                                              property map

                                              map: ModuleMap;

                                                property packages

                                                packages: PackageMap;

                                                  property paths

                                                  paths: PathMap;

                                                    interface DependencyTree

                                                    interface DependencyTree {}

                                                      property map

                                                      map?: DependencyBranch;

                                                        property path

                                                        path: string;

                                                          interface JspmConfig

                                                          interface JspmConfig {}
                                                          • Interface for the resolved JSPM config.

                                                          method getDependencyTree

                                                          getDependencyTree: (moduleName: string) => any;

                                                            interface JspmPackageJson

                                                            interface JspmPackageJson {}

                                                              property browser

                                                              browser?: Browser;

                                                                property browserTypings

                                                                browserTypings?: Browser;

                                                                  property configFiles

                                                                  configFiles?: ConfigFiles;

                                                                    property dependencies

                                                                    dependencies?: {
                                                                    [index: string]: string;

                                                                      property devDependencie

                                                                      devDependencie?: {
                                                                      [index: string]: string;

                                                                        property directories

                                                                        directories?: {
                                                                        baseURL: string;
                                                                        packages?: string;

                                                                          property main

                                                                          main: string;

                                                                            property name

                                                                            name: string;

                                                                              property overrides

                                                                              overrides?: {
                                                                              [index: string]: any;

                                                                                property peerDependencies

                                                                                peerDependencies?: {
                                                                                [index: string]: string;

                                                                                  property typings

                                                                                  typings?: string;

                                                                                    property version

                                                                                    version?: string;

                                                                                      interface JspmProjectInfo

                                                                                      interface JspmProjectInfo {}

                                                                                        property dependenciesJson

                                                                                        dependenciesJson?: DependenciesJson;

                                                                                          property jspmConfigs

                                                                                          jspmConfigs: Configs;

                                                                                            property jspmPackageJson

                                                                                            jspmPackageJson: JspmPackageJson;

                                                                                              interface ModuleMap

                                                                                              interface ModuleMap {}
                                                                                              • Module name maps to package name.

                                                                                              index signature

                                                                                              [moduleName: string]: string;

                                                                                                interface Options

                                                                                                interface Options {}

                                                                                                  property cwd

                                                                                                  cwd: string;

                                                                                                    interface Overrides

                                                                                                    interface Overrides {}
                                                                                                    • Override map for file lookups.

                                                                                                    index signature

                                                                                                    [dependency: string]: string;

                                                                                                      interface PackageMap

                                                                                                      interface PackageMap {}

                                                                                                        index signature

                                                                                                        [versionedName: string]: {
                                                                                                        map: ModuleMap;

                                                                                                          interface PathMap

                                                                                                          interface PathMap {}

                                                                                                            index signature

                                                                                                            [prefix: string]: string;

                                                                                                              Type Aliases

                                                                                                              type Browser

                                                                                                              type Browser = string | Overrides;
                                                                                                              • Browser field overrides like NPM.

                                                                                                              Package Files (5)

                                                                                                              Dependencies (9)

                                                                                                              Dev Dependencies (33)

                                                                                                              Peer Dependencies (0)

                                                                                                              No peer dependencies.


                                                                                                              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-config.

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