fs#writeFile TypeScript Examples

static write: (
    path: string,
    packageJson: JsonObject,
    space?: string | number
  ) => Promise<boolean> = (
    path: string,
    packageJson: JsonObject,
    space: string | number = 2
  ) => {
    return new Promise<boolean>((resolve, reject) => {
      const data = new Uint8Array(
        Buffer.from(JSON.stringify(packageJson, null, space))
      );
      writeFile(path, data, err => {
        if (err) {
          reject(err);
        }
        resolve(true);
      });
    });
  };

/**
 * Stringifies and writes out the content of a package.json file
 *
 * @param pkg - The package.json as an object
 */
export async function savePackageJson(pkg: Package): Promise<void> {
  const path = 'package.json';
  return new Promise<void>((resolve, reject) => {
    const str = JSON.stringify(pkg, null, 2);
    writeFile(path, str, { encoding: 'utf8' }, (err) => {
      if (err) {
        reject(err);
      }
      resolve();
    });
  });
}

setLocation(window: string, x: number, y: number): void {
        let point: Point = new Point(x, y);
        this.locations.set(window, point);
        let text: string = '{';
        this.locations.forEach((value: Point, key: string) => {
            text = text + '\"' + key + '\": {\"x\":' + value.x + ', \"y\":' + value.y + '},';
        });
        text = text.substring(0, text.length - 1) + '}'
        let json = JSON.parse(text);
        writeFile(this.file, JSON.stringify(json), (err: Error) => {
            if (err) throw err;
        });
    }

writeData() {
    if(Object.keys(this.data['weeks']).length === 0) {
      this.data['currentWeek'] = '';
      this._data.next(this.data);
    }
    writeFile(this.app.getPath('userData') + '/data.json', JSON.stringify(this.data), (err) => {
      if(err !== null) console.log(err);
    });
  }

writeDefaultData() {
    let defaultData: object = {
      "accentColor": "#0366FC",
      "language": "en",
      "darkMode": false,
      "currentWeek": "",
      "weeks": {},
      "tasks": []
    }
    writeFile(this.app.getPath('userData') + '/data.json', JSON.stringify(defaultData), (err) => {
      if(err !== null) console.log(err);
    });
  }

writeFile('./src/environments/environment.prod.ts', prodEnvironmentFile, function (err) {
  if (err) {
    throw console.error(err);
  } else {
    console.log(`environment.prod.ts file generated`);
  }
});

async showCard(card: RestyaboardCard): Promise<void> {
    if (!card) {
      vscode.window.showErrorMessage("No card selected or invalid card.");
      return;
    }
    let Cardcomments: any = await this.getcardComments(card.id, card.board_id, card.list_id);
    const cardMembers: string = this.showCardMembersAsString(card.cards_users);
    const cardLabels: string = this.showCardLabelsAsString(card.cards_labels);
    const checklistItems: string = this.showChecklistsAsMarkdown(card.cards_checklists);
    const commentItems: string = this.showCommentsAsMarkdown(Cardcomments);
    const cardCoverImageUrl = !!card.attachments && card.attachments.length > 0 ? card.attachments[0].url : "";
    const cardContentAndHeaders = [
      { header: "URL", content: card.url },
      { header: "Title", content: card.name },
      { header: "Board Name", content: card.board_name },
      { header: "List Name", content: card.list_name },
      { header: "Members", content: cardMembers },
      { header: "Labels", content: cardLabels },
      { header: "Description", content: card.description },
      { header: "Checklists", content: checklistItems },
      { header: "Comments", content: commentItems },
    ];
    if(card.due_date){
      cardContentAndHeaders.push( { header: "Due Date", content: card.due_date });
    }
    let cardContent: string = "";
    // cardContent += "| Board Name  | List Name |\n| ------------- | ------------- |\n| "+card.board_name+"  | "+card.list_name+"  |\n";
    cardContentAndHeaders.map(({ header, content }) => {
      cardContent += this.showMarkdownDecorated(header, content);
    });
    cardContent += cardCoverImageUrl ? `<img src="${cardCoverImageUrl}" alt="Image not found" />` : "";
    
    // Write temp markdown file at user's vs code default settings directory
    writeFile(this.tempRestyaboardFile, cardContent, err => {
      if (err) {
        vscode.window.showErrorMessage(`Error writing to temp file: ${err}`);
      }
      console.info(`✍ Writing to file: ${this.tempRestyaboardFile}`);
    });

    // open markdown file and preview view
    let viewColumn: vscode.ViewColumn =
      vscode.workspace.getConfiguration(SETTING_PREFIX, null).get(SETTING_CONFIG.VIEW_COLUMN) ||
      SETTING_CONFIG.DEFAULT_VIEW_COLUMN;
    if (!(VSCODE_VIEW_COLUMN.indexOf(viewColumn) > -1)) {
      vscode.window.showInformationMessage(`Invalid ${SETTING_PREFIX}.viewColumn ${viewColumn} specified`);
      viewColumn = SETTING_CONFIG.DEFAULT_VIEW_COLUMN;
    }

    const doc = await vscode.workspace.openTextDocument(this.tempRestyaboardFile);
    await vscode.window.showTextDocument(doc, viewColumn, false);
    await vscode.commands.executeCommand("markdown.showPreview");
    vscode.commands.executeCommand("markdown.preview.toggleLock");
  }

writeFileAsync = promisify(writeFile)

writeFileAsync = promisify(writeFile)

tailorGrammar = (function() {

    function updateGrammar(themeName: string) {
        const json = getJson(themeName);
        writeFile(grammarFile, json, () => commands.executeCommand('workbench.action.reloadWindow'));
        // console.log(`G-Code grammar file has been tailored to the '${themeName}' theme.`);
    
    }
    
    function tailoredForTheme() {
        const grammar = JSON.parse(readFileSync(grammarFile, 'utf8'));
        const rtn = grammar.themeName == undefined ? '' : grammar.themeName;
        // console.log(`G-Code grammar is tailored to the '${rtn}' theme.`);
        return rtn.toString();
    }

    function doUpdate(force: boolean){
        const themeName = (workspace.getConfiguration().get('workbench.colorTheme') as string);
        if(force == true || tailoredForTheme() != themeName){
            if (isThemeSupported(themeName)) {
                // console.log(`The '${themeName}' theme is supported, prompt user to update grammar`);
                if(force == true) {
                    updateGrammar(themeName);
                }
                else {
                    window.showInformationMessage(`Tailor G-Code grammer to the '${themeName}' theme?`, 'Yes', 'Not now').then(value => {
                        if (value == 'Yes') { updateGrammar(themeName) } else {console.log('User declined to tailor the grammar.');};
                    });
                }
            }
            else {
                // console.log(`G-Code grammar cannot be tailored to the '${themeName}' theme.  This theme is not supported.`);
                window.showInformationMessage(`G-Code grammer cannot be tailored to the '${themeName}' theme, this theme is not supported by the G-Code extension.`, 'Okay');
            }
        }
        else {
            // console.log(`G-Code grammar is already tailored to the '${themeName}' theme.`)
        }
    }
    

    return {
        "conditionally": function(){
            doUpdate(false)
        },
        "force": function(){
            doUpdate(true);
        }
    }
})()

writeFileAsync = promisify(writeFile)

writeFileAsync = promisify(writeFile)

writeFile('./src/environments/environment.ts', devEnvironmentFile, function (err) {
  if (err) {
    throw console.error(err);
  } else {
    console.log(`environment.ts file generated`);
  }
});

pWriteFile = promisify(writeFile)

pWriteFile = promisify(writeFile)

pWriteFile = promisify(writeFile)

writeFilePromisified = promisify(writeFile)

export function writeLocalFile(json: JsonObject): Promise<void> {
  return new Promise((resolve: (_: void) => void): void => {
    const fileContent: string = JSON.stringify(json)
    writeFile(file, fileContent, { encoding: 'utf8' }, () => {
      resolve()
    })
  })
}

async function createTrongateModuleTemplate(
  moduleName: string,
  targetDirectory: string,
  isViewTemplate: string,
  viewFileName: string,
  GLOBAL_SETTINGS: any
) {
  // The moduleName has been validated - this means no space and all lowercases

  /* upperModuleName is the name for controller php file,
    therefore the first letter needs to be uppercase */
  const upperModuleName = makeFirstLetterGoUpper(moduleName);
  await createDirectory(`${targetDirectory}/controllers`);
  await createDirectory(`${targetDirectory}/views`);
  await createDirectory(`${targetDirectory}/assets`);
  if (isViewTemplate == "yes") {
    await createDirectory(`${targetDirectory}/assets/css`);
    await createDirectory(`${targetDirectory}/assets/js`);
  }

  // const isSuperModule = GLOBAL_SETTINGS['superModule']

  // 1. check workspace - engine/ config/ modules -> pass -> this is a trongate project
  // 2. trigger language server
  // 3. communicate

  const targetControllerPath = `${targetDirectory}/controllers/${upperModuleName}.php`;
  let targetViewPath;
  let targetCSSPath;
  let targetJSPath;
  if (isViewTemplate == "yes") {
    targetViewPath = `${targetDirectory}/views/${viewFileName}.php`;
    targetCSSPath = `${targetDirectory}/assets/css/custom.css`;
    targetJSPath = `${targetDirectory}/assets/js/custom.js`;
  }
  const targetApiPath = `${targetDirectory}/assets/api.json`;
  if (existsSync(targetControllerPath)) {
    throw Error(`Module ${moduleName} already exists`);
  }
  await Promise.all([
    writeFile(
      targetControllerPath,
      getTongateControllerTemplate(GLOBAL_SETTINGS, moduleName, viewFileName),
      "utf8",
      (error) => {
        console.log(error);
      }
    ),
    // Write JS File
    isViewTemplate === "yes" &&
      writeFile(
        targetJSPath,
        "// Add your JavaScript here",
        "utf8",
        (error) => {
          console.log(error);
        }
      ),
    // Write View File
    isViewTemplate === "yes" &&
      writeFile(
        targetViewPath,
        getTrongateViewTemplate(moduleName, GLOBAL_SETTINGS),
        "utf8",
        (error) => {
          console.log(error);
        }
      ),
    // Write CSS File
    isViewTemplate === "yes" &&
      writeFile(targetCSSPath, getTrongateModuleCss(), "utf8", (error) => {
        console.log(error);
      }),

    // Write Assets file
    writeFile(targetApiPath, getTrongateAssets(moduleName), "utf8", (error) => {
      console.log(error);
    }),
  ]).catch((err) => {
    console.log(err);
  });
}