fs#readFile TypeScript Examples

private getOfflineImage(callback: SnapshotRequestCallback): void {
    const log = this.log;
    readFile(join(__dirname, `../images/offline.jpg`), (err, data) => {
      if (err) {
        log.error(err.message);
        callback(err);
      } else {
        callback(undefined, data);
      }
    });
  }

private static bibTeXFile(): Promise<string> {
    const path = this.bibTexFilePath();
    if (path == null || path == '') {
      return Promise.reject('BibTeX file location not set');
    }

    return new Promise((resolve, reject) => {
      readFile(path, (error, buffer) => {
        if (error) {
          reject(error);
        } else {
          resolve(buffer.toString());
        }
      });
    });
  }

// read fsPath into this.data and return a
  // Promise that resolves to `this` Note instance.
  // Usage:
  // note.readFile().then(note => console.log(note.data));
  readFile(useCache = false): Promise<Note> {
    // console.debug(`readFile: ${this.fsPath}`);
    let that = this;
    // if we are using the cache and cached data exists,
    // just resolve immediately without re-reading files
    if (useCache && this.data) {
      return new Promise((resolve) => {
        resolve(that);
      });
    }
    // make sure we reset parsed to false because we are re-reading the file
    // and we don't want to end up using the old parsed refCandidates
    // in the event that parseData(true) is called in the interim
    this._parsed = false;
    return new Promise((resolve, reject) => {
      readFile(that.fsPath, (err, buffer) => {
        if (err) {
          reject(err);
        } else {
          // NB! Make sure to cast this to a string
          // otherwise, it will cause weird silent failures
          that.data = `${buffer}`;
          resolve(that);
        }
      });
    });
  }

// call this when we know a file has changed contents to update the cache
  static updateCacheFor(fsPath: string) {
    let that = this;
    let note = NoteParser.parsedFileFor(fsPath);
    note.readFile(false).then((_pf) => {
      _pf.parseData(false);
      // remember to set in the master index:
      that._notes[fsPath] = _pf;
    });
  }

pReadFile = promisify(readFile)

public async readFile(filePath: string, encoding?: BufferEncoding): Promise<string> {
    this.logger.debug(() => `Reading file async: ${filePath}`);
    const deferredFileContents = new DeferredPromise<string>();

    readFile(filePath, encoding ?? this.fileEncoding, (error, data) => {
      if (error) {
        this.logger.error(() => `Failed reading file ${filePath}: ${error}`);
        deferredFileContents.reject(new Error(`Failed to read file '${filePath}': ${error}`));
      } else {
        this.logger.trace(() => `Done reading file ${filePath}: ${error}`);
        deferredFileContents.fulfill(data?.toString());
      }
    });
    return deferredFileContents.promise();
  }

_readData(): Promise<string> {
    return new Promise((resolve, reject) => {
      this.isFileExist();

      readFile(this.app.getPath('userData') + '/data.json', "utf-8", (err, data2) => {
        if(err) return reject(err);
        if(data2.length === 0) {
          this.writeDefaultData();
          this.readData();
        } else {
          return resolve(data2);
        }
      });
    });
  }

main = async (): Promise<any> => {
  const path: string = "./examples/secrets.json"
  const encoding: "utf8" = "utf8"
  const cb = async (err: any, data: any): Promise<void> => {
    if (err) throw err
    const jsonData: any = JSON.parse(data)
    const username: string = "username"
    const password: string = jsonData.password
    const user: string = jsonData.user
    const successful: boolean = await keystore.importUser(
      username,
      user,
      password
    )
    console.log(successful)
  }
  readFile(path, encoding, cb)
}

main = async (): Promise<any> => {
  const path: string = "./examples/secrets.json"
  const encoding: "utf8" = "utf8"
  const cb = async (err: any, data: any): Promise<void> => {
    if (err) throw err
    const jsonData: any = JSON.parse(data)
    const password: string = jsonData.password
    const token: string = jsonData.token
    const successful: boolean = await auth.revokeToken(password, token)
    console.log(successful)
  }
  readFile(path, encoding, cb)
}

main = async (): Promise<any> => {
  const path: string = "./examples/secrets.json"
  const encoding: "utf8" = "utf8"
  const cb = async (err: any, data: any): Promise<void> => {
    if (err) throw err
    const jsonData: any = JSON.parse(data)
    const password: string = jsonData.password
    const endpoints: string[] = ["*"]
    const token: string | ErrorResponseObject = await auth.newToken(
      password,
      endpoints
    )
    console.log(token)
  }
  readFile(path, encoding, cb)
}

main = async (): Promise<any> => {
  const path: string = "./examples/secrets.json"
  const encoding: "utf8" = "utf8"
  const cb = async (err: any, data: any): Promise<void> => {
    if (err) throw err
    const jsonData: any = JSON.parse(data)
    const oldPassword: string = jsonData.oldPassword
    const newPassword: string = jsonData.newPassword
    const successful: boolean = await auth.changePassword(
      oldPassword,
      newPassword
    )
    console.log(successful)
  }
  readFile(path, encoding, cb)
}

/**
 * Reads and parses the content of a package.json file
 *
 * @param pathSegments - The path segments of the folder where the package.json is located, relative to the root of the project
 */
export async function loadPackageJson(): Promise<Package> {
  const path = 'package.json';
  return new Promise((resolve, reject) => {
    readFile(path, (err, data) => {
      if (err) {
        reject(err);
      }
      if (!data) {
        throw new Error(`Empty file: ${path}`);
      }
      const str = data.toString('utf8');
      const json = JSON.parse(str);
      resolve(json);
    });
  });
}

export async function GetWebviewContent(rootPath: string): Promise<string> {
    const htmlPath = resolve(rootPath, 'index.html')
    const htmlContent = await new Promise<string>((resolve, reject) => readFile(htmlPath, 'utf-8', (err, data) => {
        if (err) {
            reject(err)
        } else {
            resolve(data)
        }
    }))
    return htmlContent.replace(/(<script.+?src="|<link.+?href=")(.+?)"/g, (match, $1, $2) => {
        return `${$1}${Uri.file(resolve(rootPath, $2)).with({ scheme: 'vscode-resource' })}"`
    })
}

static read: (path: string) => Promise<JsonObject> = (
    path: string
  ): Promise<any> => {
    return new Promise<any>((resolve, reject) => {
      readFile(path, (err: NodeJS.ErrnoException | null, data: Buffer) => {
        if (err) {
          reject(err);
        } else {
          try {
            resolve(JSON.parse(data.toString()));
          } catch (e) {
            reject(e);
          }
        }
      });
    });
  };

readFileAsync = async (path: string): Promise<any> => {
  try {
    const readFileAsync = promisify(readFile);
    const fileString: string = (await readFileAsync(path, 'utf-8')) as string;
    if (fileString.length === 0) {
      throw new Error(`${path} is an empty file`);
    }
    const obj = JSON.parse(fileString);
    return obj;
  } catch (err) {
    throw err;
  }
}

/* eslint-disable prefer-arrow/prefer-arrow-functions */

export function readLocalFile(): Promise<JsonObject> {
  return new Promise((resolve: (_: JsonObject) => void, reject: (error: unknown) => void): void => {
    readFile(file, { encoding: 'utf8' }, (fileReadError: unknown, fileContent: string) => {
      if (fileReadError) {
        reject(fileReadError)
      }
      try {
        const json: JsonObject = JSON.parse(fileContent)
        resolve(json)
      } catch (jsonParseError) {
        reject(jsonParseError)
      }
    })
  })
}

export async function getSettingsContents(settingsPath: string): Promise<IWTSettings> {
  const pathExists = await promisify(exists)(settingsPath);
  if (!pathExists) {
    throw Error('Expected settings file does not exist: ' + settingsPath);
  }

  const rawString = (await promisify(readFile)(settingsPath))?.toString();
  if (!rawString) {
    throw Error('Could not read settings file');
  }

  return jsoncParser.parse(rawString) as IWTSettings;
}

private updateForFile(filename: string) {
        // Inside a small timeout because it seems chikidar is "too fast"
        // and reading the file will then return empty content
        setTimeout(() => {
            readFile(filename, 'utf-8', (error, contents) => {
                if (error) {
                    return;
                }

                const globalVarsForFile = contents
                    .split('\n')
                    .map((line) => line.match(varRegex))
                    .filter(isNotNullOrUndefined)
                    .map((line) => ({ filename, name: line[1], value: line[2] }));
                this.globalVars.set(filename, globalVarsForFile);
            });
        }, 1000);
    }

router = {
  checkRoute (url: string, _req: IncomingMessage, res: ServerResponse) {
    switch (url) {
      case ('/'): {
        readFile('build/web/pages/index.html', (err: Error, data: Buffer) => {
          if (err) throw err
          res.end(data)
        })
        break
      }
      case ('/authorized'): {
        readFile('build/web/pages/authorized.html', (err: Error, data: Buffer) => {
          if (err) throw err
          res.end(data)
        })
        break
      }
      case ('/login'): {
        readFile('build/web/pages/login.html', (err: Error, data: Buffer) => {
          if (err) throw err
          res.end(data)
        })
        break
      }
      case ('/error'): {
        readFile('build/web/pages/error.html', (err: Error, data: Buffer) => {
          if (err) throw err
          res.end(data)
        })
        break
      }
      default: {
        res.end('An error occurred.')
      }
    }
  }
}

readFilePromised = promisify(readFile)

readFileAsync = promisify(readFile)

readFileAsync = promisify(readFile)

readFileAsync = promisify(readFile)

readFileAsync = promisify(readFile)

static async parsedFilesForWorkspace(useCache = false): Promise<Array<Note>> {
    let files = await NoteWorkspace.noteFiles();
    let parsedFiles = files.map((f) => NoteParser.parsedFileFor(f.fsPath));
    return (await Promise.all(parsedFiles.map((note) => note.readFile(useCache)))).map((note) => {
      note.parseData(useCache);
      return note;
    });
  }

readFileAsync = promisify(readFile)

readFileAsync = promisify(readFile)

pReadFile = promisify(readFile)

pReadFile = promisify(readFile)