util#TextDecoder TypeScript Examples

async deserializeNotebook(
    context: Uint8Array,
    _token: vscode.CancellationToken
  ): Promise<vscode.NotebookData> {
    const str = new TextDecoder().decode(context);
    const blocks = splitSqlBlocks(str);

    const cells = blocks.map((query) => {
      const isMarkdown = query.startsWith('/*markdown') && query.endsWith('*/');
      if (isMarkdown) {
        const lines = query.split('\n');
        const innerMarkdown =
          lines.length > 2 ? lines.slice(1, lines.length - 1).join('\n') : '';
        return new vscode.NotebookCellData(
          vscode.NotebookCellKind.Markup,
          innerMarkdown,
          'markdown'
        );
      }

      return new vscode.NotebookCellData(
        vscode.NotebookCellKind.Code,
        query,
        'sql'
      );
    });
    return new vscode.NotebookData(cells);
  }

constructor(
    name: string,
    url: string,
    actions: BlockchainAction[],
    contract: string,
    account?: BlockchainAccount,
  ) {
    super(name, url, actions, contract, account);

    let keys = [];
    if (this.account) {
      keys = [this.account.privateKey];
    }
    const signatureProvider = new JsSignatureProvider(keys);
    const rpc = new JsonRpc(url, { fetch });

    this.client = new Api({
      rpc,
      signatureProvider,
      textEncoder: new TextEncoder(),
      textDecoder: new TextDecoder(),
    });
  }

constructor(config: NetworkConfig) {
    super(config);
    const signatureProvider = new JsSignatureProvider([]);
    const rpc = new JsonRpc(this.url(), { fetch });

    this.client = new Api({
      rpc,
      signatureProvider,
      textEncoder: new TextEncoder(),
      textDecoder: new TextDecoder(),
    });
  }

decoder = new TextDecoder("utf-8")

async function getWebviewContent(
  context: vscode.ExtensionContext,
  panel: vscode.WebviewPanel
) {
  const webviewPath = vscode.Uri.file(
    path.join(context.extensionPath, "static", "webview.html")
  );
  const file = await vscode.workspace.fs.readFile(webviewPath);

  const text = new TextDecoder("utf-8").decode(file);

  const webviewUri = (fileName: string) =>
    panel.webview
      .asWebviewUri(
        vscode.Uri.file(path.join(context.extensionPath, "static", fileName))
      )
      .toString();

  const graphDirectory = path.join("graphs", getConfiguration("graphType"));
  const textWithVariables = text
    .replace(
      "${graphPath}",
      "{{" + path.join(graphDirectory, "graph.js") + "}}"
    )
    .replace(
      "${graphStylesPath}",
      "{{" + path.join(graphDirectory, "graph.css") + "}}"
    );

  // Basic templating. Will replace {{someScript.js}} with the
  // appropriate webview URI.
  const filled = textWithVariables.replace(/\{\{.*\}\}/g, (match) => {
    const fileName = match.slice(2, -2).trim();
    return webviewUri(fileName);
  });

  return filled;
}

static readonly utf8Decoder = Coder.define(new TextDecoder('utf8'));

static readonly latin1Decoder = Coder.define(new TextDecoder('latin1'));

customGlobal.TextDecoder = TextDecoder;

readUTF(): string {
        const length = this.readUnsignedShort()
            , start = this.advance(length);
        return new TextDecoder().decode(this.buf.slice(start, start + length));
    }

api = new Api({
  rpc,
  signatureProvider,
  textDecoder: new TextDecoder(),
  textEncoder: new TextEncoder(),
})

decoder = new TextDecoder('utf-8')

decoder = new TextDecoder('utf-8')

decoder = new TextDecoder('utf-8')

parseFile = async (graph: Graph, filePath: string) => {
  filePath = path.normalize(filePath);
  const buffer = await vscode.workspace.fs.readFile(vscode.Uri.file(filePath));
  const content = new TextDecoder("utf-8").decode(buffer);
  const ast: MarkdownNode = parser.parse(content);

  let title: string | null = findTitle(ast);

  const index = graph.nodes.findIndex((node) => node.path === filePath);

  if (!title) {
    if (index !== -1) {
      graph.nodes.splice(index, 1);
    }

    return;
  }

  if (index !== -1) {
    graph.nodes[index].label = title;
  } else {
    graph.nodes.push({ id: id(filePath), path: filePath, label: title });
  }

  // Remove edges based on an old version of this file.
  graph.edges = graph.edges.filter((edge) => edge.source !== id(filePath));

  // Returns a list of decoded links (by default markdown only supports encoded URI)
  const links = findLinks(ast).map(uri => decodeURI(uri));
  const parentDirectory = filePath.split(path.sep).slice(0, -1).join(path.sep);

  for (const link of links) {
    let target = path.normalize(link);
    if (!path.isAbsolute(link)) {
      target = path.normalize(`${parentDirectory}/${link}`);
    }

    graph.edges.push({ source: id(filePath), target: id(target) });
  }
}

findFileId = async (filePath: string): Promise<string | null> => {
  const buffer = await vscode.workspace.fs.readFile(vscode.Uri.file(filePath));
  const content = new TextDecoder("utf-8").decode(buffer);

  const match = content.match(FILE_ID_REGEXP);
  return match ? match[1] : null;
}

describe('test contract-files-reader', () => {
  describe('readABIFile()', () => {
    it('should throw error when missing file path', () => {
      expect(() => {
        // @ts-ignore
        readABIFile(undefined);
      }).toThrowError('File path is required.');
    });

    it('should throw error when missing API instance', () => {
      expect(() => {
        // @ts-ignore
        readABIFile('some/path');
      }).toThrowError('Missing EOS API instance');
    });

    it('should read file and return serialized hex content', () => {
      const api = new Api({
        rpc: new JsonRpc('some_url', { fetch }),
        signatureProvider: new JsSignatureProvider([]),
        textEncoder: new TextEncoder(),
        textDecoder: new TextDecoder(),
      });

      const testFileBuffer = Buffer.from('{ "test": "test content" }', 'utf-8');
      const readFileSyncMock = jest
        .spyOn(fs, 'readFileSync')
        .mockReturnValueOnce(testFileBuffer.toString('utf-8'));

      const res = readABIFile('some/path', api);
      expect(typeof res).toBe('string');
    });
  });

  describe('readWASMFile()', () => {
    it('should throw error when missing file path', () => {
      expect(() => {
        // @ts-ignore
        readWASMFile(undefined);
      }).toThrowError('File path is required.');
    });

    it('should throw Not Found error when reading from not-existing file', () => {
      const path = 'not/existing/file/path';

      expect(() => {
        readWASMFile(path);
      }).toThrowError('File not found!');
    });

    it('should throw error when reading failed', () => {
      const path = 'not/existing/file/path';
      const readFileSyncMock = jest.spyOn(fs, 'readFileSync').mockImplementationOnce(() => {
        throw new Error('Test Error');
      });

      expect(() => {
        readWASMFile(path);
      }).toThrowError('Test Error');
      expect(readFileSyncMock).toBeCalledWith(path);
    });

    it('should read file and convert to hex string', () => {
      const testFileBuffer = Buffer.from('test content', 'utf-8');
      const readFileSyncMock = jest.spyOn(fs, 'readFileSync').mockReturnValueOnce(testFileBuffer);
      const wasmPath = 'some/wasm/path';

      const result = readWASMFile(wasmPath);
      expect(result).toBe(testFileBuffer.toString('hex'));
      expect(readFileSyncMock).toBeCalledWith(wasmPath);
    });
  });

  describe('readPSFile()', () => {
    it('should throw error when missing file path', () => {
      expect(() => {
        // @ts-ignore
        readPSFile(undefined);
      }).toThrowError('File path is required.');
    });

    it('should throw Not Found error when reading from not-existing file', () => {
      const path = 'not/existing/file/path';

      expect(() => {
        readPSFile(path);
      }).toThrowError('File not found!');
    });

    it('should throw error when reading failed', () => {
      const path = 'not/existing/file/path';
      const readFileSyncMock = jest.spyOn(fs, 'readFileSync').mockImplementationOnce(() => {
        throw new Error('Test Error');
      });

      expect(() => {
        readPSFile(path);
      }).toThrowError('Test Error');
      expect(readFileSyncMock).toBeCalledWith(path);
    });

    it('should read file and convert to hex string', () => {
      const testFileBuffer = Buffer.from('test content', 'utf-8');
      const readFileSyncMock = jest.spyOn(fs, 'readFileSync').mockReturnValueOnce(testFileBuffer);
      const psPath = 'some/ps/path';

      const result = readPSFile(psPath);
      expect(result).toBe(testFileBuffer.toString('hex'));
      expect(readFileSyncMock).toBeCalledWith(psPath);
    });
  });
});