How to use snappyjs - 9 common examples

code: '',
    label: { basic: true, children: 'URL', size: 'tiny' },
    text: 'Shared code example (unsaved)',
    type: 'shared',
    value: `custom-${Date.now()}`
  };

  try {
    const compStr = atob(base64);
    const compU8a = new Uint8Array(compStr.length);

    compU8a.forEach((_, i): void => {
      compU8a[i] = compStr.charCodeAt(i);
    });

    const u8a = snappy.uncompress(compU8a);
    const code = util.u8aToString(u8a);

    sharedExample.code = code;
  } catch (error) {
    const errorMessage = 'ERROR: Unable to decode code example from URL';

    console.error(`${errorMessage}: \n${error}`);
    sharedExample.code = `// ${errorMessage}`;
  }

  return sharedExample;
}

function read_rawimage_results(features) {
  // ignore data for now and use results
  // const compressed_data = results.responses[0].features[0].raw_image.compressed_data;
  const compressed_data = features[0].raw_image.compressed_data;
  const binary_compressed_data = base64ToUint8Array(compressed_data);
  const jsonBuf = snappyjs.uncompress(binary_compressed_data);

  var enc = new TextDecoder("utf-8");
  const json = enc.decode(jsonBuf);

  var imagedata = JSON.parse(json);
  var width = results.responses[0].features[0].raw_image.width
  var height = results.responses[0].features[0].raw_image.height
  var img = new Image(width, height, imagedata, {kind: "RGB"})
  var rgbaimg = img.rgba8();
  return rgbaimg.toDataURL();
}

let data = stream.readBitStream(bitCount);

	if (isCompressed) {
		const decompressedByteSize = data.readUint32();
		const compressedByteSize = data.readUint32();

		const magic = data.readASCIIString(4);

		const compressedData = data.readArrayBuffer(compressedByteSize - 4); // 4 magic bytes

		if (magic !== 'SNAP') {
			throw new Error('Unknown compressed stringtable format');
		}

		const decompressedData = uncompress(compressedData);
		if (decompressedData.byteLength !== decompressedByteSize) {
			throw new Error('Incorrect length of decompressed stringtable');
		}

		data = new BitStream(decompressedData.buffer as ArrayBuffer);
	}

	const table: StringTable = {
		name: tableName,
		entries: [],
		maxEntries,
		fixedUserDataSize: userDataSize,
		fixedUserDataSizeBits: userDataSizeBits,
		compressed: isCompressed
	};

export function EncodeCreateStringTable(packet: CreateStringTablePacket, stream: BitStream) {
	stream.writeASCIIString(packet.table.name);
	stream.writeUint16(packet.table.maxEntries);
	const encodeBits = logBase2(packet.table.maxEntries);
	const numEntries = packet.table.entries.filter((entry) => entry).length;
	stream.writeBits(numEntries, encodeBits + 1);

	let entryData = new BitStream(new ArrayBuffer(guessStringTableEntryLength(packet.table, packet.table.entries)));
	encodeStringTableEntries(entryData, packet.table, packet.table.entries);

	if (packet.table.compressed) {
		const decompressedByteLength = Math.ceil(entryData.length / 8);
		entryData.index = 0;
		const compressedData = compress(entryData.readArrayBuffer(decompressedByteLength));
		entryData = new BitStream(new ArrayBuffer(decompressedByteLength));
		entryData.writeUint32(decompressedByteLength);
		entryData.writeUint32(compressedData.byteLength + 4); // 4 magic bytes
		entryData.writeASCIIString('SNAP', 4);
		const typeForce: any = compressedData.buffer;
		entryData.writeArrayBuffer(typeForce as BitStream);
	}
	const entryLength = entryData.index;
	entryData.index = 0;

	writeVarInt(entryLength, stream);

	if (packet.table.fixedUserDataSize || packet.table.fixedUserDataSizeBits) {
		stream.writeBoolean(true);
		stream.writeBits(packet.table.fixedUserDataSize || 0, 12);
		stream.writeBits(packet.table.fixedUserDataSizeBits || 0, 4);

function uncompress(msg) {
    try {
      return {
        value: SnappyJS.uncompress(msg)
      }
    } catch (error) {
      return {
        error
      }
    }
  }

function inflate_snappy(value) {
  return snappy.uncompress(value);
}

function compress(msg) {
    try {
      return {
        value: SnappyJS.compress(Buffer.from(msg))
      }
    } catch (error) {
      return {
        error
      }
    }
  }

function deflate_snappy(value) {
  return snappy.compress(value);
}

const _generateLink = (): void => {
    const u8a = util.stringToU8a(code);
    const compU8a = snappy.compress(u8a);
    const compStr = compU8a.reduce((str: string, ch: number): string => {
      return str + String.fromCharCode(ch);
    }, '');

    const base64code = btoa(compStr);
    const path = `/js/share/${base64code}`;

    if (base64code !== base64) {
      history.push(path);
    }

    const basePath = window.location.pathname.replace('/', '').length > 0
      ? `${window.location.origin}/${window.location.pathname.replace('/', '')}`
      : `${window.location.origin}`;

    _copyToClipboard(`${basePath}/#${path}`);