feat: initial version

Author: csimi

.editorconfig

@@ -0,0 +1,11 @@
+root = true
+
+[*]
+end_of_line = lf
+insert_final_newline = true
+indent_style = tab
+charset = utf-8
+
+[{package.json,*.yml}]
+indent_style = space
+indent_size = 2

.eslintignore

@@ -0,0 +1,2 @@
+node_modules
+coverage

.eslintrc.json

@@ -0,0 +1,13 @@
+{
+	"env": {
+		"node": true,
+		"es6": true
+	},
+	"parserOptions": {
+		"ecmaVersion": 2018,
+		"sourceType": "script"
+	},
+	"extends": [
+		"@csimi/eslint-config"
+	]
+}

.github/workflows/nodejs.yml

@@ -0,0 +1,38 @@
+name: build
+
+on:
+  pull_request:
+    types:
+      - opened
+      - synchronize
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+
+    strategy:
+      matrix:
+        node-version: [10.x, 12.x]
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v1
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+    - name: npm install, build, and test
+      run: |
+        npm ci
+        npm run build --if-present
+        npm test
+      env:
+        CI: true
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v1
+      if: matrix.node-version == '12.x'
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}

.gitignore

@@ -0,0 +1,4 @@
+node_modules
+npm-debug.log*
+coverage
+.nyc_output

.mocharc.json

@@ -0,0 +1,4 @@
+{
+	"recursive": true,
+	"file": ["test/setup.js"]
+}

.nycrc.json

@@ -0,0 +1,7 @@
+{
+	"all": true,
+	"produce-source-map": true,
+	"include": [
+		"lib/**"
+	]
+}

lib/const.js

@@ -0,0 +1,41 @@
+const MARKER_LENGTH = 1;
+const NUMBER = 0x00;
+const BOOLEAN = 0x01;
+const STRING = 0x02;
+const OBJECT = 0x03;
+const MOVIECLIP = 0x04;
+const NULL = 0x05;
+const UNDEFINED = 0x06;
+const REFERENCE = 0x07;
+const ECMA_ARRAY = 0x08;
+const OBJECT_END = 0x09;
+const STRICT_ARRAY = 0x0A;
+const DATE = 0x0B;
+const LONG_STRING = 0x0C;
+const UNSUPPORTED = 0x0D;
+const RECORDSET = 0x0E;
+const XML_DOCUMENT = 0x0F;
+const TYPED_OBJECT = 0x10;
+const AVMPLUS_OBJECT = 0x11;
+
+module.exports = {
+	MARKER_LENGTH,
+	NUMBER,
+	BOOLEAN,
+	STRING,
+	OBJECT,
+	MOVIECLIP,
+	NULL,
+	UNDEFINED,
+	REFERENCE,
+	ECMA_ARRAY,
+	OBJECT_END,
+	STRICT_ARRAY,
+	DATE,
+	LONG_STRING,
+	UNSUPPORTED,
+	RECORDSET,
+	XML_DOCUMENT,
+	TYPED_OBJECT,
+	AVMPLUS_OBJECT,
+};

lib/index.js

@@ -0,0 +1,109 @@
+const {
+	MARKER_LENGTH,
+	NUMBER,
+	BOOLEAN,
+	STRING,
+	OBJECT,
+	NULL,
+	LONG_STRING,
+	UNDEFINED,
+	STRICT_ARRAY,
+	DATE,
+} = require('./const');
+const {
+	encodeNumber,
+	decodeNumber,
+} = require('./types/number');
+const {
+	encodeBoolean,
+	decodeBoolean,
+} = require('./types/boolean');
+const {
+	encodeString,
+	decodeString,
+} = require('./types/string');
+const {
+	encodeObject,
+	decodeObject,
+} = require('./types/object');
+const {
+	encodeNull,
+	decodeNull,
+} = require('./types/null');
+const {
+	encodeUndefined,
+	decodeUndefined,
+} = require('./types/undefined');
+const {
+	encodeArray,
+	decodeArray,
+} = require('./types/array');
+const {
+	encodeDate,
+	decodeDate,
+} = require('./types/date');
+
+const toAMF = (value) => {
+	const type = typeof value;
+	switch (type) {
+		case 'number':
+			return encodeNumber(value);
+		case 'boolean':
+			return encodeBoolean(value);
+		case 'string':
+			return encodeString(value);
+		case 'object':
+			if (value === null) {
+				return encodeNull(value);
+			}
+			if (value instanceof Array) {
+				return encodeArray(value, toAMF);
+			}
+			if (value instanceof Date) {
+				return encodeDate(value);
+			}
+			return encodeObject(value, toAMF);
+		case 'undefined':
+			return encodeUndefined(value);
+		default:
+			throw new Error(`Cannot encode unknown type of ${type}`);
+	}
+};
+
+const decodeAMF = (buffer, memo) => {
+	const type = buffer.readUInt8(memo.pos);
+	memo.pos += MARKER_LENGTH;
+	switch (type) {
+		case NUMBER:
+			return decodeNumber(buffer, memo);
+		case BOOLEAN:
+			return decodeBoolean(buffer, memo);
+		case STRING:
+		case LONG_STRING:
+			return decodeString(buffer, memo, type);
+		case OBJECT:
+			return decodeObject(buffer, memo, decodeAMF);
+		case NULL:
+			return decodeNull(buffer, memo);
+		case UNDEFINED:
+			return decodeUndefined(buffer, memo);
+		case STRICT_ARRAY:
+			return decodeArray(buffer, memo, decodeAMF);
+		case DATE:
+			return decodeDate(buffer, memo);
+		default:
+			throw new Error(`Cannot decode unknown type of ${type}`);
+	}
+};
+
+const fromAMF = (buffer) => {
+	const memo = {
+		'pos': 0,
+	};
+	return decodeAMF(buffer, memo);
+};
+
+module.exports = {
+	toAMF,
+	fromAMF,
+};

lib/types/array.js

@@ -0,0 +1,36 @@
+const {
+	MARKER_LENGTH,
+	STRICT_ARRAY,
+} = require('../const');
+
+const ARRAY_LENGTH = 4;
+
+const encodeArray = (value, toAMF) => {
+	const buf = Buffer.allocUnsafe(MARKER_LENGTH + ARRAY_LENGTH);
+	
+	buf.writeUInt8(STRICT_ARRAY, 0);
+	buf.writeUInt32BE(value.length, MARKER_LENGTH);
+	
+	return Buffer.concat([
+		buf,
+		...value.map(toAMF),
+	]);
+};
+
+const decodeArray = (buf, memo, decodeAMF) => {
+	const data = [];
+	
+	const length = buf.readUInt32BE(memo.pos);
+	memo.pos += ARRAY_LENGTH;
+	
+	while (data.length < length) {
+		data.push(decodeAMF(buf, memo));
+	}
+	
+	return data;
+};
+
+module.exports = {
+	encodeArray,
+	decodeArray,
+};

lib/types/boolean.js

@@ -0,0 +1,20 @@
+const {
+	BOOLEAN,
+} = require('../const');
+
+const BOOLEAN_LENGTH = 1;
+
+const encodeBoolean = (value) => {
+	return Buffer.from([BOOLEAN, Number(value)]);
+};
+
+const decodeBoolean = (buf, memo) => {
+	const value = Boolean(buf.readUInt8(memo.pos));
+	memo.pos += BOOLEAN_LENGTH;
+	return value;
+};
+
+module.exports = {
+	encodeBoolean,
+	decodeBoolean,
+};

lib/types/date.js

@@ -0,0 +1,28 @@
+const {
+	MARKER_LENGTH,
+	DATE,
+} = require('../const');
+
+const DATE_LENGTH = 8;
+const DATE_TIMEZONE_LENGTH = 2;
+
+const encodeDate = (date) => {
+	const buf = Buffer.allocUnsafe(MARKER_LENGTH + DATE_LENGTH + DATE_TIMEZONE_LENGTH);
+	
+	buf.writeUInt8(DATE, 0);
+	buf.writeDoubleBE(date.valueOf(), MARKER_LENGTH);
+	buf.writeUInt16BE(0, MARKER_LENGTH + DATE_LENGTH);
+	
+	return buf;
+};
+
+const decodeDate = (buf, memo) => {
+	const value = new Date(buf.readDoubleBE(memo.pos));
+	memo.pos += DATE_LENGTH + DATE_TIMEZONE_LENGTH;
+	return value;
+};
+
+module.exports = {
+	encodeDate,
+	decodeDate,
+};

lib/types/null.js

@@ -0,0 +1,16 @@
+const {
+	NULL,
+} = require('../const');
+
+const encodeNull = () => {
+	return Buffer.from([NULL]);
+};
+
+const decodeNull = () => {
+	return null;
+};
+
+module.exports = {
+	encodeNull,
+	decodeNull,
+};

lib/types/number.js

@@ -0,0 +1,26 @@
+const {
+	MARKER_LENGTH,
+	NUMBER,
+} = require('../const');
+
+const NUMBER_LENGTH = 8;
+
+const encodeNumber = (value) => {
+	const buf = Buffer.allocUnsafe(MARKER_LENGTH + NUMBER_LENGTH);
+	
+	buf.writeUInt8(NUMBER, 0);
+	buf.writeDoubleBE(value, MARKER_LENGTH);
+	
+	return buf;
+};
+
+const decodeNumber = (buf, memo) => {
+	const value = buf.readDoubleBE(memo.pos);
+	memo.pos += NUMBER_LENGTH;
+	return value;
+};
+
+module.exports = {
+	encodeNumber,
+	decodeNumber,
+};