url#fileURLToPath TypeScript Examples

__dirname = dirname(fileURLToPath(import.meta.url))

load: Load = async function (uri, context, fallback) {
	// note: inline `getFormat`
	let options = await toOptions(uri);
	if (options == null) return fallback(uri, context, fallback);
	let format: Format = options.format === 'cjs' ? 'commonjs' : 'module';

	// TODO: decode SAB/U8 correctly
	let path = fileURLToPath(uri);
	let source = await fs.readFile(path);

	// note: inline `transformSource`
	esbuild = esbuild || await import('esbuild');
	let result = await esbuild.transform(source.toString(), {
		...options,
		sourcefile: path,
		format: format === 'module' ? 'esm' : 'cjs',
	});

	return { format, source: result.code };
}

private handleDrag(e?: any) {
    const ev = new QDragMoveEvent(e as NativeElement);

    try {
      const mimeData = ev.mimeData();

      if (mimeData.hasUrls()) {
        const url = new URL(mimeData.text());

        if (url.protocol !== 'file:') {
          return;
        }

        this.attachments.addFiles([fileURLToPath(url.href)]);
      }

      ev.accept();
    } catch (ex) {}
  }

async function handleRequest(url: string) {
  const uri = new URL(url);
  const roundify = uri.searchParams.get('roundify') === 'true';
  const path = join(paths.cache, `.${uri.pathname}${roundify ? '.round' : ''}`);

  if (uri.hostname === 'cdn.discordapp.com') {
    if (existsSync(path)) {
      return path;
    }
  }

  await mkdir(dirname(path), { recursive: true });
  let buffer = await (uri.protocol === 'file:' ? readFile(fileURLToPath(url)) : httpsGet(url));

  if (buffer && buffer.length) {
    buffer = await processPng(buffer, roundify);

    await writeFile(path, buffer as Buffer);

    return path;
  }

  return null;
}

server = polka({ onError: errorHandler, onNoMatch: notFoundHandler })
  .use(
    helmet() as Middleware,
    sirv(resolve(dirname(fileURLToPath(import.meta.url)), "./views"), {
      dev: process.env.NODE_ENV !== "production",
      etag: true,
      maxAge: 60 * 60 * 24
    })
  )
  .get("/")
  .options("/api", cors)
  .post("/api", cors, rateLimiter, bodyParser, coreHandler)

__dirname = path.dirname(fileURLToPath(import.meta.url))

__dirname = path.dirname(fileURLToPath(import.meta.url))

__filename = fileURLToPath(import.meta.url)

function handleUrls(container:HTMLElement, article:HTMLElement, header:HTMLElement, mdPrevious: string):void {
    for(const link of container.getElementsByTagName('a')){
        link.onclick = () => {
            window.history.replaceState("", "", pathToFileURL(mdPrevious))
            // Handle links with the whitelisted protocols
            if(new URL(link.href).protocol.match(trustedProtocolRegExp)) {
                open(link.href)
            // Handle in-document links
            } else if (link.href.startsWith(document.URL.replace(/#.*/, '')+'#')) {
                const id = getId(link.href);
                if (id) {
                    const element = document.getElementById(id)
                    if(element) element.scrollIntoView({behavior: "smooth"});
                }
            // Handle markdown links and 'LICENSE' files.
            } else if(link.href.match(/^file:\/\/.+(\.md|LICENSE)(#[a-z0-9-]+)?$/)) {
                const mdFile = fileURLToPath(link.href);
                const id = getId(link.href);
                const oldHeader = menuHeader.innerHTML
                menuHeader.innerText = basename(mdFile);
                document.body.removeChild(article);
                if(existsSync(mdFile)){
                    loadMarkdown(container,mdFile);
                    mdPrevious = mdFile;
                } else {
                    // Fix for HTML links ('<a>' elements) that are unhandled by marked.
                    const relFile = relative(document.URL, link.href);
                    const mdFile = resolve(mdPrevious, relFile);
                    if(!existsSync(mdFile)) {
                        // Failsafe: revert all changes done so far...
                        console.error("File '"+mdFile+"' does not exists!");
                        document.body.appendChild(article);
                        window.history.pushState("", "", htmlFileUrl);
                        menuHeader.innerHTML = oldHeader;
                        return false;
                    }
                    loadMarkdown(container,mdFile);
                    mdPrevious = mdFile;
                    console.log(relFile);
                }
                window.scroll(0,0);
                handleUrls(container, article, header, mdPrevious);
                fixImages(container);
                document.body.appendChild(article);
                if (id) {
                    const element = document.getElementById(id);
                    if (element) element.scrollIntoView();
                }
            }
            window.history.pushState("", "", htmlFileUrl)
            return false;
        }
    }
}

PACKAGE_JSON_PATH = path.join(path.dirname(fileURLToPath(import.meta.url)), '..', 'package.json')

resolveSync = (id: string) => {
    const callerUrl = caller();
    const callerPath = callerUrl.startsWith('file://') ? fileURLToPath(callerUrl) : callerUrl;
    return resolveCore.sync(id, {basedir: callerPath});
}

__dirname = path.dirname(fileURLToPath(import.meta.url))

__dirname = dirname(fileURLToPath(import.meta.url))

function check(fileurl: string): string | void {
	let tmp = fileURLToPath(fileurl);
	if (existsSync(tmp)) return fileurl;
}

__filename = fileURLToPath(import.meta.url)

__filename = fileURLToPath(import.meta.url)