How to use url-join - 10 common examples

canvasJson.items[0].id = urljoin(this.url.href, 'index.json/canvas', index, 'annotationpage/0');

                await canvas.read(canvasJson);

                // add canvas to items
                this.indexJson.items.push(canvasJson);

                index++;
            }

            this.indexJson.items.sort((a, b) => {
                return Utils.compare(a.id, b.id);
            });
        }

        this.indexJson.id = urljoin(this.url.href, 'index.json');

        this._applyInfo();

        await Utils.getThumbnail(this.indexJson, this);

        // write index.json
        const path: string = join(this.directoryPath, 'index.json');
        const json: string = JSON.stringify(this.indexJson, null, '  ');

        console.log(chalk.green('creating index.json for: ') + this.directoryPath);

        await Utils.writeJson(path, json);
    }

loadKeymapMode(keymapMode) {
    const loadCss = this.loadCss;
    const scriptList = [];
    const cssList = [];

    // add dependencies
    if (this.loadedKeymapSet.size === 0) {
      const dialogScriptUrl = this.props.noCdn
        ? urljoin(this.cmNoCdnScriptRoot, 'codemirror-dialog.js')
        : urljoin(this.cmCdnRoot, 'addon/dialog/dialog.min.js');
      const dialogStyleUrl = this.props.noCdn
        ? urljoin(this.cmNoCdnStyleRoot, 'codemirror-dialog.css')
        : urljoin(this.cmCdnRoot, 'addon/dialog/dialog.min.css');

      scriptList.push(loadScript(dialogScriptUrl));
      cssList.push(loadCss(dialogStyleUrl));
    }
    // load keymap
    if (!this.loadedKeymapSet.has(keymapMode)) {
      const keymapScriptUrl = this.props.noCdn
        ? urljoin(this.cmNoCdnScriptRoot, `codemirror-keymap-${keymapMode}.js`)
        : urljoin(this.cmCdnRoot, `keymap/${keymapMode}.min.js`);
      scriptList.push(loadScript(keymapScriptUrl));
      // update Set
      this.loadedKeymapSet.add(keymapMode);

loadTheme(theme) {
    if (!this.loadedThemeSet.has(theme)) {
      const url = this.props.noCdn
        ? urljoin(this.cmNoCdnStyleRoot, `codemirror-theme-${theme}.css`)
        : urljoin(this.cmCdnRoot, `theme/${theme}.min.css`);

      this.loadCss(url);

      // update Set
      this.loadedThemeSet.add(theme);
    }
  }

urlJoin: function() {
        // need varargs but Handlebars adds an arg to the end, so slice it off
        var args = Array.apply(null, arguments).slice(0, arguments.length-1);
        return urljoin.apply(null, args);
    },

function openAuthPage(config: AppConfig) {
  Linking.openURL(encodeURI(urlJoin(
    config.auth.serverUri,
    '/api/rest/oauth2/auth',
    '?response_type=code',
    '&access_type=offline',
    `&client_id=${config.auth.clientId}`,
    `&scope=${config.auth.scopes}`,
    `&redirect_uri=${config.auth.landingUrl}`
  )));
}

serverConfig: ServerConfig,
  kernelID: string,
  sessionID?: string
): string => {
  const params = new URLSearchParams();
  if (serverConfig.token) {
    params.append("token", serverConfig.token);
  }
  if (sessionID) {
    params.append("session_id", sessionID);
  }

  const q = params.toString();
  const suffix = q !== "" ? `?${q}` : "";

  const url = urljoin(
    serverConfig.endpoint || "",
    `/api/kernels/${kernelID}/channels${suffix}`
  );

  return url.replace(/^http(s)?/, "ws$1");
};

request(`${query.base}.json`, function (err, response, body) {
        if (err) return res.status(400).send(err.toString());
        if (response.statusCode != 200) return res.status(response.statusCode).send(body);
        try {
          options.data = JSON.parse(body);
        } catch (ex) {
          return res.status(400).send(ex.toString());
        }
        res.render('offline', {
          options,
          baseUrl: `${urlJoin(pathReverse(ownPath), sharedPath)}`
        });
      });
    });

export const attributePath = (id: string) => urlJoin(attributeSection, id);
export const attributeUrl = (id: string, params?: AttributeUrlQueryParams) =>

readFile: (remotePath, options, callback) => {
            const cb = typeof options === "function" ? options : callback;
            const url = joinURL(BASE_URL, "/get/file");
            createSession()
                .encrypt(remotePath, token)
                .then(payload =>
                    fetch(url, {
                        method: "POST",
                        headers: {
                            "Content-Type": "application/json; charset=utf-8"
                        },
                        body: JSON.stringify({
                            payload
                        })
                    })
                )
                .then(response => {
                    if (response.ok && response.status === 200) {
                        return response.json();

async getUserFromHub(id: string) {
    const queryString = qs.stringify({fields: 'avatar/url'});
    return await this.makeAuthorizedRequest(
      urlJoin(this.auth.config.auth.serverUri, `/api/rest/users/${id}?${queryString}`)
    );
  }