@iotize/device-com-nfc.cordova 3.8.0 → 3.9.0-alpha.4

package/bundles/iotize-device-com-nfc.cordova.umd.js

@@ -18,7 +18,7 @@
   OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
   PERFORMANCE OF THIS SOFTWARE.
   ***************************************************************************** */
-  /* global Reflect, Promise, SuppressedError, Symbol */
+  /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
   var extendStatics = function (d, b) {
       extendStatics = Object.setPrototypeOf ||
           ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
@@ -154,8 +154,8 @@
   }
   function __generator(thisArg, body) {
       var _ = { label: 0, sent: function () { if (t[0] & 1)
-              throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
+              throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+      return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function () { return this; }), g;
       function verb(n) { return function (v) { return step([n, v]); }; }
       function step(op) {
           if (f)
@@ -310,9 +310,13 @@
       if (!Symbol.asyncIterator)
           throw new TypeError("Symbol.asyncIterator is not defined.");
       var g = generator.apply(thisArg, _arguments || []), i, q = [];
-      return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-      function verb(n) { if (g[n])
-          i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+      return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+      function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+      function verb(n, f) { if (g[n]) {
+          i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); };
+          if (f)
+              i[n] = f(i[n]);
+      } }
       function resume(n, v) { try {
           step(g[n](v));
       }
@@ -392,7 +396,7 @@
       if (value !== null && value !== void 0) {
           if (typeof value !== "object" && typeof value !== "function")
               throw new TypeError("Object expected.");
-          var dispose;
+          var dispose, inner;
           if (async) {
               if (!Symbol.asyncDispose)
                   throw new TypeError("Symbol.asyncDispose is not defined.");
@@ -402,9 +406,18 @@
               if (!Symbol.dispose)
                   throw new TypeError("Symbol.dispose is not defined.");
               dispose = value[Symbol.dispose];
+              if (async)
+                  inner = dispose;
           }
           if (typeof dispose !== "function")
               throw new TypeError("Object not disposable.");
+          if (inner)
+              dispose = function () { try {
+                  inner.call(this);
+              }
+              catch (e) {
+                  return Promise.reject(e);
+              } };
           env.stack.push({ value: value, dispose: dispose, async: async });
       }
       else if (async) {
@@ -421,18 +434,26 @@
           env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
           env.hasError = true;
       }
+      var r, s = 0;
       function next() {
-          while (env.stack.length) {
-              var rec = env.stack.pop();
+          while (r = env.stack.pop()) {
               try {
-                  var result = rec.dispose && rec.dispose.call(rec.value);
-                  if (rec.async)
-                      return Promise.resolve(result).then(next, function (e) { fail(e); return next(); });
+                  if (!r.async && s === 1)
+                      return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                  if (r.dispose) {
+                      var result = r.dispose.call(r.value);
+                      if (r.async)
+                          return s |= 2, Promise.resolve(result).then(next, function (e) { fail(e); return next(); });
+                  }
+                  else
+                      s |= 1;
               }
               catch (e) {
                   fail(e);
               }
           }
+          if (s === 1)
+              return env.hasError ? Promise.reject(env.error) : Promise.resolve();
           if (env.hasError)
               throw env.error;
       }
@@ -536,16 +557,22 @@
       switch (message.tnf) {
           case exports.TNF.ABSOLUTE_URI:
               return {
+                  id: message.id,
+                  type: message.type,
                   tnf: 'uri',
                   value: toAsciiString(message.payload),
               };
           case exports.TNF.WELL_KNOWN_TYPE:
               return {
+                  id: message.id,
+                  type: message.type,
                   tnf: 'wkt',
                   value: parseWellKnownType(message),
               };
           case exports.TNF.EMPTY:
               return {
+                  id: message.id,
+                  type: message.type,
                   tnf: 'empty',
                   value: {
                       type: message.type,
@@ -554,16 +581,22 @@
               };
           case exports.TNF.EXTERNAL:
               return {
+                  id: message.id,
+                  type: message.type,
                   tnf: 'external',
                   value: paseExternalType(message),
               };
           case exports.TNF.MIME_TYPE:
               return {
+                  id: message.id,
+                  type: message.type,
                   tnf: 'mimetype',
                   value: parseMimeType(message),
               };
           case exports.TNF.RFU:
               return {
+                  id: message.id,
+                  type: message.type,
                   tnf: 'rfu',
                   value: {
                       type: message.type,
@@ -572,6 +605,8 @@
               };
           case exports.TNF.UNCHANGED:
               return {
+                  id: message.id,
+                  type: message.type,
                   tnf: 'unchanged',
                   value: {
                       type: message.type,
@@ -580,6 +615,8 @@
               };
           case exports.TNF.UNKNOWN:
               return {
+                  id: message.id,
+                  type: message.type,
                   tnf: 'unknown',
                   value: {
                       type: message.type,
@@ -588,6 +625,8 @@
               };
           default:
               return {
+                  id: message.id,
+                  type: message.type,
                   tnf: message.tnf,
                   value: {
                       type: message.type,
@@ -597,7 +636,7 @@
       }
   }
   function parseWellKnownType(message) {
-      if (arrayEquals(message.type, WellKnownType.URI)) {
+      if (arrayEquals(message.type.slice(), WellKnownType.URI)) {
           var prefixCode = message.payload[0];
           var prefix = WELL_KNOWN_TYPE_URI_PREFIX[prefixCode] || '';
           return {
@@ -605,7 +644,7 @@
               value: prefix + toAsciiString(message.payload.slice(1)),
           };
       }
-      else if (arrayEquals(message.type, WellKnownType.TEXT)) {
+      else if (arrayEquals(message.type.slice(), WellKnownType.TEXT)) {
           var encodingNumber = message.payload[0];
           var encoding = 'utf8';
           var languageSizeInBytes = 0;
@@ -620,12 +659,15 @@
               languageSizeInBytes = encodingNumber & 63;
           }
           var text = message.payload.slice(languageSizeInBytes + 1);
+          var language = message.payload.slice(8, languageSizeInBytes + 1);
           return {
               type: 'text',
               value: buffer.Buffer.from(text).toString(encoding),
+              encoding: encoding,
+              language: buffer.Buffer.from(language).toString(encoding)
           };
       }
-      //   else if (arrayEquals(message.type, WellKnownType.SMPART_POSTER)) {
+      //   else if (arrayEquals(message.type.slice(), WellKnownType.SMPART_POSTER)) {
       //     return {
       //       type: 'sp',
       //       // TODO implement
@@ -636,7 +678,7 @@
           return {
               type: 'unknown',
               value: {
-                  type: message.type,
+                  type: message.type.slice(),
                   payload: message.payload,
               },
           };
@@ -689,6 +731,124 @@
   };
   function parseMimeType(message) {
       return buffer.Buffer.from(message.payload).toString('utf8');
+  }
+  function encodeWellKnownType(message) {
+      var e_1, _a;
+      if (message.value.type == 'uri') {
+          //identify the prefix
+          var prefixesEntries = Object.entries(WELL_KNOWN_TYPE_URI_PREFIX);
+          var prefixByte = 0;
+          try {
+              for (var prefixesEntries_1 = __values(prefixesEntries), prefixesEntries_1_1 = prefixesEntries_1.next(); !prefixesEntries_1_1.done; prefixesEntries_1_1 = prefixesEntries_1.next()) {
+                  var _b = __read(prefixesEntries_1_1.value, 2), id = _b[0], prefix = _b[1];
+                  if (id == '0x0') // Skip first as it is always recognized. (what about 0x1 vs 0x2?)
+                      continue;
+                  if (message.value.value.startsWith(prefix)) {
+                      prefixByte = parseInt(id, 16);
+                      break;
+                  }
+              }
+          }
+          catch (e_1_1) { e_1 = { error: e_1_1 }; }
+          finally {
+              try {
+                  if (prefixesEntries_1_1 && !prefixesEntries_1_1.done && (_a = prefixesEntries_1.return)) _a.call(prefixesEntries_1);
+              }
+              finally { if (e_1) throw e_1.error; }
+          }
+          var lengthToSlice = WELL_KNOWN_TYPE_URI_PREFIX[prefixByte].length;
+          var slicedString = message.value.value.slice(lengthToSlice);
+          return __spreadArray([prefixByte], __read((byteConverter.asciiStringToByteBuffer(slicedString))));
+      }
+      else if (message.value.type === 'text') {
+          // b1: RFU (set to 0)
+          // b2-b7: la taille en octets de la langue (n)
+          // B8-B8+n-1: language
+          // Bn: message
+          var firstByte = message.value.encoding == 'utf16le' ? 128 : 0;
+          firstByte &= (message.value.language & 63);
+          var languageBytes = buffer.Buffer.from(message.value.language, message.value.encoding);
+          var textBytes = buffer.Buffer.from(message.value.value, message.value.encoding);
+          return __spreadArray(__spreadArray([firstByte], __read(languageBytes)), __read(textBytes));
+      }
+      else
+          return __spreadArray(__spreadArray([], __read(message.value.type)), __read(message.value.payload));
+  }
+  function encodeExternalType(message) {
+      return Array.from(buffer.Buffer.from(message.value.value, 'utf8'));
+  }
+  function encodeMimeType(message) {
+      return Array.from(buffer.Buffer.from(message.value, 'utf8'));
+  }
+  function encodeNDEFMessages(ndefRecords) {
+      return (ndefRecords || []).map(encodeNDEFMessage);
+  }
+  function encodeNDEFMessage(ndefRecord) {
+      switch (ndefRecord.tnf) {
+          case 'uri':
+              return {
+                  id: ndefRecord.id,
+                  type: ndefRecord.type,
+                  tnf: exports.TNF.ABSOLUTE_URI,
+                  payload: Array.from(byteConverter.asciiStringToByteBuffer(ndefRecord.value))
+              };
+          case 'wkt':
+              return {
+                  id: ndefRecord.id,
+                  type: ndefRecord.type,
+                  tnf: exports.TNF.WELL_KNOWN_TYPE,
+                  payload: encodeWellKnownType(ndefRecord),
+              };
+          case 'empty':
+              return {
+                  id: ndefRecord.id,
+                  type: ndefRecord.type,
+                  tnf: exports.TNF.EMPTY,
+                  payload: ndefRecord.payload,
+              };
+          case 'external':
+              return {
+                  id: ndefRecord.id,
+                  type: ndefRecord.type,
+                  tnf: exports.TNF.EXTERNAL,
+                  payload: encodeExternalType(ndefRecord),
+              };
+          case 'mimetype':
+              return {
+                  id: ndefRecord.id,
+                  type: ndefRecord.type,
+                  tnf: exports.TNF.MIME_TYPE,
+                  payload: encodeMimeType(ndefRecord),
+              };
+          case 'rfu':
+              return {
+                  id: ndefRecord.id,
+                  type: ndefRecord.type,
+                  tnf: exports.TNF.RFU,
+                  payload: ndefRecord.payload
+              };
+          case 'unchanged':
+              return {
+                  id: ndefRecord.id,
+                  type: ndefRecord.type,
+                  tnf: exports.TNF.UNCHANGED,
+                  payload: ndefRecord.payload,
+              };
+          case 'unknown':
+              return {
+                  id: ndefRecord.id,
+                  type: ndefRecord.type,
+                  tnf: exports.TNF.UNKNOWN,
+                  payload: ndefRecord.payload,
+              };
+          default:
+              return {
+                  id: ndefRecord.id,
+                  type: ndefRecord.type,
+                  tnf: Number(ndefRecord.tnf),
+                  payload: ndefRecord.payload,
+              };
+      }
   }
 
   var debug = debug$1.createDebugger("@iotize/device-com-nfc.cordova");
@@ -970,6 +1130,8 @@
 
   exports.NFCComProtocol = NFCComProtocol;
   exports.WellKnownType = WellKnownType;
+  exports.encodeNDEFMessage = encodeNDEFMessage;
+  exports.encodeNDEFMessages = encodeNDEFMessages;
   exports.parseNdefMessage = parseNdefMessage;
   exports.parseNdefMessages = parseNdefMessages;
   exports.parseTapNdefMessage = parseTapNdefMessage;