Tribhuwan-Joshi

const fs = require('node:fs/promises');
const path = require('path');
let c = 1;
async function fn(p, FolderName) {
  const items = await fs.readdir(p, { withFileTypes: true });
  for (i of items) {
    if (i.isDirectory()) {
      if (i.name == FolderName) {
        console.log(i);
        await fs.cp(path.join(i.parentPath, i.name), `./all/finished-${c++}`, {

Tribhuwan-Joshi

const inputButton = document.getElementById("inputtag");
const buttonn = document.querySelector(".btn");
inputButton.addEventListener("change", async (e) => await updateFile(e));
buttonn.addEventListener("click", () => uploadFile());

let data = null;
async function updateFile(e) {
  const file = e.target.files[0];

  const formData = new FormData();

Tribhuwan-Joshi

import NextAuth from "next-auth";
import GithubProvider from "next-auth/providers/github";

export const authOptions = {
  providers: [
    GithubProvider({
      clientId: process.env.GITHUB_ID ?? "",
      clientSecret: process.env.GITHUB_SECRET ?? "",
    }),
  ],

Tribhuwan-Joshi

const express = require("express");
const jwt = require("jsonwebtoken");

const app = express();

app.get("/api", (req, res) => {
  res.json({
    message: "Welcome to the API",
  });
});

Tribhuwan-Joshi

const express = require("express");
const path = require("path");
const session = require("express-session");
const passport = require("passport");
const LocalStrategy = require("passport-local").Strategy;
const mongoose = require("mongoose");

const User = require("./models/user");
const {
  getUser,

Tribhuwan-Joshi

/*
A throttled function is first called without delay and then, for a time interval of t milliseconds, can't be executed but should store the latest function arguments provided to call fn with them after the end of the delay. 
*/

const throttle = function (fn , t){
  let intervalInProgress = null; 
  let argsToProcess = null; 
  
const intervalFunction = () =>{
  if(argsToProcess == null){

Tribhuwan-Joshi

const promisePool = async function(functions, n) {
async function evaluateNext(){
  if(functions.length == 0 ) return ;
  const fn = functions.shift();
  await fn();
  await evaluateNext();   // call the function recursively until the function ends
}
const nPromises = Array(n).fill().map(evaluateNext);   // create array of size n to call the evalute next fn.
await Promise.all(nPromises);  // wait for all promise to resolve
};

Tribhuwan-Joshi

/**
 * @param {Function} fn
 * @param {number} t
 * @return {Function}
 */
var timeLimit = function(fn, t) {
	return async function(...args) {
      return   Promise.race([new Promise((res,rej)=>setTimeout(()=>rej("Time Limit Exceeded"),t)) , fn(...args) ])
        
    }

Tribhuwan-Joshi

async function sleep(millis){
  return new Promise(res => setTimeout(res,millis) )   // return a promise that will resolve after  millis milliseconds
}

const t = Date.now();
sleep(100).then(()=>console.log(Date.now() - t ));

Tribhuwan-Joshi

const curry = function (fn){
  return function currying(...args){
    if(args.length >= fn.length ){
  return fn(...args);
    }
else {
  return function(...args2){
    return currying.apply(...args.concat(args2))
  }
}