699 lines
25 KiB
JavaScript
699 lines
25 KiB
JavaScript
// Copyright 2014 Cognitect. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS-IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
"use strict";
|
|
|
|
goog.provide("com.cognitect.transit");
|
|
goog.require("com.cognitect.transit.util");
|
|
goog.require("com.cognitect.transit.impl.reader");
|
|
goog.require("com.cognitect.transit.impl.writer");
|
|
goog.require("com.cognitect.transit.types");
|
|
goog.require("com.cognitect.transit.eq");
|
|
goog.require("com.cognitect.transit.impl.decoder");
|
|
goog.require("com.cognitect.transit.caching");
|
|
|
|
/** @define {boolean} */
|
|
var TRANSIT_DEV = true;
|
|
|
|
/** @define {boolean} */
|
|
var TRANSIT_NODE_TARGET = false;
|
|
|
|
/** @define {boolean} */
|
|
var TRANSIT_BROWSER_TARGET = false;
|
|
|
|
/** @define {boolean} */
|
|
var TRANSIT_BROWSER_AMD_TARGET = false;
|
|
|
|
goog.scope(function() {
|
|
|
|
/**
|
|
* @class transit
|
|
*/
|
|
var transit = com.cognitect.transit;
|
|
|
|
var util = com.cognitect.transit.util,
|
|
reader = com.cognitect.transit.impl.reader,
|
|
writer = com.cognitect.transit.impl.writer,
|
|
decoder = com.cognitect.transit.impl.decoder,
|
|
types = com.cognitect.transit.types,
|
|
eq = com.cognitect.transit.eq,
|
|
caching = com.cognitect.transit.caching;
|
|
|
|
/**
|
|
* @typedef {Map|com.cognitect.transit.types.TransitArrayMap|com.cognitect.transit.types.TransitMap}
|
|
*/
|
|
transit.MapLike;
|
|
|
|
/**
|
|
* @typedef {Set|com.cognitect.transit.types.TransitSet}
|
|
*/
|
|
transit.SetLike;
|
|
|
|
/**
|
|
* Create a transit reader instance.
|
|
* @method transit.reader
|
|
* @param {string=} type
|
|
* type of reader to construct. Default to "json". For verbose mode
|
|
* supply "json-verbose".
|
|
* @param {Object=} opts
|
|
* reader options. A JavaScript object to customize the writer Valid
|
|
* entries include "defaultHandler", and "handler". "defaultHandler"
|
|
* should be JavaScript function taking two arguments, the first is the
|
|
* tag, the second the value. "handlers" should be an object of tags to
|
|
* handle. The values are functions that will receive the value of matched
|
|
* tag. "preferBuffers" may be supplied to customize binary
|
|
* decoding. If available binary data will read as Node.js Buffers,
|
|
* If Buffer is not available or "prefersBuffers" is set to false
|
|
* data will be read as Uint8Array. If neither Buffer nor Uint8Array is
|
|
* available - defaults to tagged value that simply wraps the
|
|
* base64 encoded string.
|
|
* @return {com.cognitect.transit.impl.reader.Reader} A transit reader.
|
|
* @example
|
|
* var r = transit.reader("json", {
|
|
* handlers: {
|
|
* "point": function(v) { return new Point(v[0], v[1]); }
|
|
* }
|
|
* });
|
|
*/
|
|
transit.reader = function(type, opts) {
|
|
if(type === "json" || type === "json-verbose" || type == null) {
|
|
type = "json";
|
|
var unmarshaller = new reader.JSONUnmarshaller(opts);
|
|
return new reader.Reader(unmarshaller, opts);
|
|
} else {
|
|
throw new Error("Cannot create reader of type " + type);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Create a transit writer instance.
|
|
* @method transit.writer
|
|
* @param {string=} type
|
|
* type of writer to construct. Defaults to "json". For verbose mode
|
|
* supply "json-verbose".
|
|
* @param {Object=} opts
|
|
* writer options. A JavaScript object to customize the writer.
|
|
* "handlers" options, a transit.map of JavaScript constructor and
|
|
* transit writer handler instance entries. "handlerForForeign" option,
|
|
* for dealing with values from other JavaScript contexts. This function
|
|
* will be passed the unmatchable value and the installed handlers. The
|
|
* function should return the correct handler. Note if this function is
|
|
* provided, special handling for Objects will also be
|
|
* auto-installed to catch plain Objects from the foreign context.
|
|
* @return {com.cognitect.transit.impl.writer.Writer} A transit writer.
|
|
* @example
|
|
* var r = transit.writer("json", {
|
|
* handlers: transit.map([
|
|
* Point, PointHandler
|
|
* ])
|
|
* });
|
|
*/
|
|
transit.writer = function(type, opts) {
|
|
if(type === "json" || type === "json-verbose" || type == null) {
|
|
if(type === "json-verbose") {
|
|
if(opts == null) opts = {};
|
|
opts["verbose"] = true;
|
|
}
|
|
var marshaller = new writer.JSONMarshaller(opts);
|
|
return new writer.Writer(marshaller, opts);
|
|
} else {
|
|
var err = new Error("Type must be \"json\"");
|
|
err.data = {type: type};
|
|
throw err;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Create a transit writer handler.
|
|
* @method transit.makeWriteHandler
|
|
* @param {Object} obj
|
|
* An object containing 3 functions, tag, rep and stringRep. "tag" should
|
|
* return a string representing the tag to be written on the wire. "rep"
|
|
* should return the representation on the wire. "stringRep" is should
|
|
* return the string representation of the value. Optional
|
|
* "getVerboseHandler" should return a handler for writing verbose output.
|
|
* @return {Object} A transit write handler.
|
|
* @example
|
|
* var PointHandler = transit.makeWriteHandler({
|
|
* tag: function(p) { return "point"; },
|
|
* rep: function(p) { return [p.x, p.y]; },
|
|
* stringRep: function(p) { return null; }
|
|
* });
|
|
*/
|
|
transit.makeWriteHandler = function(obj) {
|
|
/** @constructor */
|
|
var Handler = function(){};
|
|
Handler.prototype.tag = obj["tag"];
|
|
Handler.prototype.rep = obj["rep"];
|
|
Handler.prototype.stringRep = obj["stringRep"];
|
|
Handler.prototype.getVerboseHandler = obj["getVerboseHandler"];
|
|
return new Handler();
|
|
};
|
|
|
|
transit.makeBuilder = function(obj) {
|
|
/** @constructor */
|
|
var Builder = function(){};
|
|
Builder.prototype.init = obj["init"];
|
|
Builder.prototype.add = obj["add"];
|
|
Builder.prototype.finalize = obj["finalize"];
|
|
Builder.prototype.fromArray = obj["fromArray"];
|
|
return new Builder();
|
|
};
|
|
|
|
/**
|
|
* Create a transit date.
|
|
* @method transit.date
|
|
* @param {number|string} x
|
|
* A number or string representing milliseconds since epoch.
|
|
* @return {Date} A JavaScript Date.
|
|
*/
|
|
transit.date = types.date;
|
|
|
|
/**
|
|
* Create an integer. If given a transit integer or a JavaScript
|
|
* number will simply return that value. Given a string will
|
|
* return a JavaScript number if the string represents an integer
|
|
* value in the 53bit range and a transit integer otherwise.
|
|
* @method transit.integer
|
|
* @param {number|string} s
|
|
* A value representing an integer.
|
|
* @return {number|goog.math.Long} A JavaScript number or transit integer.
|
|
*/
|
|
transit.integer = types.intValue;
|
|
|
|
/**
|
|
* Test if an object is a transit integer. Will return true if argument
|
|
* is a 64 bit integer or a JavaScript number that has an interpretation as
|
|
* an integer value, i.e. parseFloat(n) === parseInt(n)
|
|
* @method transit.isInteger
|
|
* @param {*} x
|
|
* Any JavaScript value.
|
|
* @return {boolean} true if the value is a transit integer, false otherwise.
|
|
*/
|
|
transit.isInteger = types.isInteger;
|
|
|
|
/**
|
|
* Create transit UUID from a string
|
|
* @method transit.uuid
|
|
* @param {string} s
|
|
* A string.
|
|
* @return {com.cognitect.transit.types.UUID} A transit UUID.
|
|
*/
|
|
transit.uuid = types.uuid;
|
|
|
|
/**
|
|
* Test if an object is a transit UUID.
|
|
* @method transit.isUUID
|
|
* @param {*} x
|
|
* Any JavaScript value.
|
|
* @return {boolean} true if the vlaue is a transit UUID instance, false otherwise.
|
|
*/
|
|
transit.isUUID = types.isUUID;
|
|
|
|
/**
|
|
* Create a transit big integer.
|
|
* @method transit.bigInt
|
|
* @param {string} s
|
|
* A string representing an arbitrary size integer value.
|
|
* @return {com.cognitect.transit.types.TaggedValue} A transit big integer.
|
|
*/
|
|
transit.bigInt = types.bigInteger;
|
|
|
|
/**
|
|
* Test if an object is a transit big integer.
|
|
* @method transit.isBigInt
|
|
* @param {*} x
|
|
* Any JavaScript value.
|
|
* @return {boolean} true if x is a transit big integer, false otherwise.
|
|
*/
|
|
transit.isBigInt = types.isBigInteger;
|
|
|
|
/**
|
|
* Create a transit big decimal.
|
|
* @method transit.bigDec
|
|
* @param {string} s
|
|
* A string representing an arbitrary precisions decimal value.
|
|
* @return {com.cognitect.transit.types.TaggedValue} A transit big decimal.
|
|
*/
|
|
transit.bigDec = types.bigDecimalValue;
|
|
|
|
/**
|
|
* Test if an object is a transit big decimal.
|
|
* @method transit.isBigDec
|
|
* @param {*} x
|
|
* Any JavaScript value.
|
|
* @return {boolean} true if x is a transit big decimal, false otherwise.
|
|
*/
|
|
transit.isBigDec = types.isBigDecimal;
|
|
|
|
/**
|
|
* Create transit keyword.
|
|
* @method transit.keyword
|
|
* @param {string} name A string.
|
|
* @return {com.cognitect.transit.types.Keyword} A transit keyword.
|
|
* @example
|
|
* transit.keyword("foo");
|
|
*/
|
|
transit.keyword = types.keyword;
|
|
|
|
/**
|
|
* Test if an object is a transit keyword.
|
|
* @method transit.isKeyword
|
|
* @param {*} x
|
|
* Any JavaScript value.
|
|
* @return {boolean} true if x is a transit keyword, false otherwise.
|
|
*/
|
|
transit.isKeyword = types.isKeyword;
|
|
|
|
/**
|
|
* Create a transit symbol.
|
|
* @method transit.symbol
|
|
* @param {string} name
|
|
* A string.
|
|
* @return {com.cognitect.transit.types.Symbol} A transit symbol instance.
|
|
* @example
|
|
* transit.symbol("foo");
|
|
*/
|
|
transit.symbol = types.symbol;
|
|
|
|
/**
|
|
* Test if an object is a transit symbol
|
|
* @method transit.isSymbol
|
|
* @param {*} x
|
|
* Any JavaScript value.
|
|
* @return {boolean} true if x is a transit symbol, false otherwise.
|
|
*/
|
|
transit.isSymbol = types.isSymbol;
|
|
|
|
/**
|
|
* Create transit binary blob.
|
|
* @method transit.binary
|
|
* @param {string} s
|
|
* A base64 encoded string.
|
|
* @param {*=} decoder
|
|
* A Transit compliant decoder
|
|
* @return {com.cognitect.transit.types.TaggedValue|Uint8Array} A transit binary blob instance.
|
|
*/
|
|
transit.binary = types.binary;
|
|
|
|
/**
|
|
* Test if an object is a transit binary blob.
|
|
* @method transit.isBinary
|
|
* @param {*} x
|
|
* Any JavaScript value.
|
|
* @return {Boolean} true if x is a binary value, false otheriwse.
|
|
*/
|
|
transit.isBinary = types.isBinary;
|
|
|
|
/**
|
|
* Create a transit URI.
|
|
* @method transit.uri
|
|
* @param {string} s
|
|
* A string representing a valid URI.
|
|
* @return {com.cognitect.transit.types.TaggedValue} A transit URI.
|
|
*/
|
|
transit.uri = types.uri;
|
|
|
|
/**
|
|
* Test if an object is a transit URI.
|
|
* @method transit.isURI
|
|
* @param {*} x
|
|
* Any JavaScript value.
|
|
* @return {Boolean} true if x is a transit symbol, false otherwise.
|
|
*/
|
|
transit.isURI = types.isURI;
|
|
|
|
/**
|
|
* Create a transit hash map. Transit maps satisfy the current version
|
|
* of the ECMAScript 6 Map specification.
|
|
* @method transit.map
|
|
* @param {Array=} xs
|
|
* A JavaScript array of alternating key value pairs.
|
|
* @return {com.cognitect.transit.MapLike} A transit map.
|
|
* @example
|
|
* transit.map([new Date(), "foo", [1,2], 3]);
|
|
*/
|
|
transit.map = types.map;
|
|
|
|
/**
|
|
* Test if an object is a transit map.
|
|
* @method transit.isMap
|
|
* @param {*} x
|
|
* Any JavaScript value.
|
|
* @return {boolean} true if x is a transit map, false otherwise.
|
|
*/
|
|
transit.isMap = types.isMap;
|
|
|
|
/**
|
|
* Create a transit set. Transit sets satisfy the current version of the
|
|
* of the ECMAScript 6 Set specification.
|
|
* @method transit.set
|
|
* @param {Array=} xs
|
|
* A JavaScript array of values.
|
|
* @return {com.cognitect.transit.SetLike} A transit set.
|
|
* @example
|
|
* transit.set(["foo", [1,2], 3, {bar: "baz"}]);
|
|
*/
|
|
transit.set = types.set;
|
|
|
|
/**
|
|
* Test if an object is a transit set.
|
|
* @method transit.isSet
|
|
* @param {*} x
|
|
* Any JavaScript value.
|
|
* @return {boolean} true if x is a transit set, false otherwise.
|
|
*/
|
|
transit.isSet = types.isSet;
|
|
|
|
/**
|
|
* Create a transit list.
|
|
* @method transit.list
|
|
* @param {Array} xs
|
|
* A JavaScript array.
|
|
* @return {com.cognitect.transit.types.TaggedValue} A transit list.
|
|
*/
|
|
transit.list = types.list;
|
|
|
|
/**
|
|
* Test if an object is a transit list.
|
|
* @method transit.isList
|
|
* @param {*} x
|
|
* Any JavaScript value.
|
|
* @return {boolean} true if x is a transit list, false otherwise.
|
|
*/
|
|
transit.isList = types.isList;
|
|
|
|
/**
|
|
* Create a transit quoted value.
|
|
* @method transit.quoted
|
|
* @param {*} x
|
|
* Any JavaScript value.
|
|
* @return {com.cognitect.transit.types.TaggedValue} A transit quoted value.
|
|
*/
|
|
transit.quoted = types.quoted;
|
|
|
|
/**
|
|
* Test if an object is a transit quoted value.
|
|
* @method transit.isQuoted
|
|
* @param {*} x
|
|
* Any JavaScript value.
|
|
* @return {boolean} true if x is a transit value, false otherwise.
|
|
*/
|
|
transit.isQuoted = types.isQuoted;
|
|
|
|
/**
|
|
* Create a transit tagged value.
|
|
* @method transit.tagged
|
|
* @param {string} tag A tag.
|
|
* @param {*} value
|
|
* A JavaScrpt array, object, or string.
|
|
* @return {com.cognitect.transit.types.TaggedValue} A transit tagged value.
|
|
* @example
|
|
* transit.tagged("point", new Point(1,2));
|
|
*/
|
|
transit.tagged = types.taggedValue;
|
|
|
|
/**
|
|
* Test if an object is a transit tagged value.
|
|
* @method transit.isTaggedValue
|
|
* @param {*} x
|
|
* Any JavaScript value.
|
|
* @return {boolean} true if x is a transit value, false otherwise.
|
|
*/
|
|
transit.isTaggedValue = types.isTaggedValue;
|
|
|
|
/**
|
|
* Create a transit link.
|
|
* @method transit.link
|
|
* @param {com.cognitect.transit.MapLike} m
|
|
* A transit map which must contain at a minimum the following keys:
|
|
* href, rel. It may optionally include name, render, and prompt. href
|
|
* must be a transit.uri, all other values are strings, and render must
|
|
* be either "image" or "link".
|
|
* @return {Object} A transit link.
|
|
*/
|
|
transit.link = types.link;
|
|
|
|
/**
|
|
* Test if an object is a transit link.
|
|
* @method transit.isLink
|
|
* @param {*} x
|
|
* Any JavaScript object.
|
|
* @return {boolean} true if x is a transit link, false otherwise.
|
|
*/
|
|
transit.isLink = types.isLink;
|
|
|
|
/**
|
|
* Compute the hashCode for any JavaScript object that has been
|
|
* extend to transit's equality and hashing protocol. JavaScript
|
|
* primitives and transit value are already extended to this protocol.
|
|
* Custom types may be extended to the protocol via transit.extenToEQ.
|
|
* @method transit.hash
|
|
* @param {*} x
|
|
* Any JavaScript object that has been extended to transit's equality
|
|
* and hashing protocol.
|
|
* @return {number} Returns JavaScript number - semantically a 32bit integer.
|
|
*/
|
|
transit.hash = eq.hashCode;
|
|
|
|
/**
|
|
* Compute the hashCode for JavaScript map-like types - either a JavaScript
|
|
* object or a JavaScript object that implements ES6 Map forEach.
|
|
* @method transit.hashMapLike
|
|
* @param {Object|com.cognitect.transit.MapLike} x
|
|
* A plain JavaScript Object or Object that implements ES6 Map forEach.
|
|
* @return {number} Returns JavaScript number - semantically a 32bit integer.
|
|
*/
|
|
transit.hashMapLike = eq.hashMapLike;
|
|
|
|
/**
|
|
* Compute the hashCode for JavaScript array-like types - either a JavaScript
|
|
* array or a JavaScript object that implements Array forEach.
|
|
* @method transit.hashArrayLike
|
|
* @param {Object} x
|
|
* A JavaScript Array or Object that implements Array forEach.
|
|
* @return {number} Returns JavaScript number - semantically a 32bit integer.
|
|
*/
|
|
transit.hashArrayLike = eq.hashArrayLike;
|
|
|
|
/**
|
|
* Test whether two JavaScript objects represent equal values. The
|
|
* objects to be tested should be extended to transit's equality
|
|
* and hasing protocol. JavaScript natives and transit value have
|
|
* already been extended to the protocol, including objects and
|
|
* arrays. Also transit maps and JavaScript objects may be
|
|
* compared for equality. Custom types may be extended via
|
|
* transit.extendToEQ.
|
|
* @param {*} x
|
|
* A JavaScript object
|
|
* @param {*} y
|
|
* A JavaScript object
|
|
* @return {Boolean} true if the x and y are equal, false otherwise.
|
|
*/
|
|
transit.equals = eq.equals;
|
|
|
|
/**
|
|
* Extend an object to hashing and equality required by
|
|
* transit maps and sets. Only required for custom
|
|
* types, JavaScript primitive types and transit
|
|
* types are handled.
|
|
* @method transit.extendToEQ
|
|
* @param {*} x
|
|
* A JavaScript object, will be mutated.
|
|
* @param {{hashCode: function(), equals: function(*,*):boolean}}
|
|
* A JavaScript object supplying `hashCode` and `equals`
|
|
* implementations
|
|
* @return {*} x
|
|
* @example
|
|
* transit.extendToEq(Point.protototype, {
|
|
* hashCode: function() {
|
|
* var bits = (this.x | 0) ^ ((this.y | 0) * 31);
|
|
* return bits ^ (bits >>> 32);
|
|
* },
|
|
* equals: function(other) {
|
|
* return this.x == other.x && this.y == other.y;
|
|
* }
|
|
* });
|
|
*/
|
|
transit.extendToEQ = eq.extendToEQ;
|
|
|
|
/**
|
|
* Convert a transit map instance into a JavaScript Object.
|
|
* Throws if the map has keys which have no string representation.
|
|
* @method transit.mapToObject
|
|
* @param {com.cognitect.transit.MapLike} m
|
|
* a transit map
|
|
* @return {Object} a JavaScript Object
|
|
*/
|
|
transit.mapToObject = function(m) {
|
|
var ret = {};
|
|
m.forEach(function(v, k) {
|
|
if(typeof k !== "string") {
|
|
throw Error("Cannot convert map with non-string keys");
|
|
} else {
|
|
ret[k] = v;
|
|
}
|
|
});
|
|
return ret;
|
|
};
|
|
|
|
/**
|
|
* Convert a POJO into a transit map.
|
|
* @method transit.objectToMap
|
|
* @param {Object} obj
|
|
* a JavaScript Object
|
|
* @return {com.cognitect.transit.MapLike} a transit map
|
|
*/
|
|
transit.objectToMap = function(obj) {
|
|
var ret = transit.map();
|
|
for(var p in obj) {
|
|
if(obj.hasOwnProperty(p)) {
|
|
ret.set(p, obj[p]);
|
|
}
|
|
}
|
|
return ret;
|
|
};
|
|
|
|
/**
|
|
* Construct a Transit JSON decoder.
|
|
* @method transit.decoder
|
|
* @param {Object} opts
|
|
* options to the decoder. Can include map of
|
|
* handlers.
|
|
* @return {com.cognitect.transit.impl.decoder.Decoder} a Transit JSON decoder
|
|
* @example
|
|
* var decoder = transit.decoder();
|
|
* var x = decoder.decode(json, transit.readCache());
|
|
*/
|
|
transit.decoder = decoder.decoder;
|
|
|
|
/**
|
|
* Construct a Transit read cache
|
|
* @method transit.readCache
|
|
* @return {com.cognitect.transit.caching.ReadCache} a Transit read cache
|
|
*/
|
|
transit.readCache = caching.readCache;
|
|
|
|
/**
|
|
* Construct a Transit write cache
|
|
* @method transit.writeCache
|
|
* @return {com.cognitect.transit.caching.WriteCache} a Transit write cache
|
|
*/
|
|
transit.writeCache = caching.writeCache;
|
|
|
|
transit.UUIDfromString = types.UUIDfromString;
|
|
transit.randomUUID = util.randomUUID;
|
|
transit.stringableKeys = writer.stringableKeys;
|
|
|
|
if(TRANSIT_BROWSER_TARGET) {
|
|
goog.exportSymbol("transit.reader", transit.reader);
|
|
goog.exportSymbol("transit.writer", transit.writer);
|
|
goog.exportSymbol("transit.makeBuilder", transit.makeBuilder);
|
|
goog.exportSymbol("transit.makeWriteHandler", transit.makeWriteHandler);
|
|
goog.exportSymbol("transit.date", types.date);
|
|
goog.exportSymbol("transit.integer", types.intValue);
|
|
goog.exportSymbol("transit.isInteger", types.isInteger);
|
|
goog.exportSymbol("transit.uuid", types.uuid);
|
|
goog.exportSymbol("transit.isUUID", types.isUUID);
|
|
goog.exportSymbol("transit.bigInt", types.bigInteger);
|
|
goog.exportSymbol("transit.isBigInt", types.isBigInteger);
|
|
goog.exportSymbol("transit.bigDec", types.bigDecimalValue);
|
|
goog.exportSymbol("transit.isBigDec", types.isBigDecimal);
|
|
goog.exportSymbol("transit.keyword", types.keyword);
|
|
goog.exportSymbol("transit.isKeyword", types.isKeyword);
|
|
goog.exportSymbol("transit.symbol", types.symbol);
|
|
goog.exportSymbol("transit.isSymbol", types.isSymbol);
|
|
goog.exportSymbol("transit.binary", types.binary);
|
|
goog.exportSymbol("transit.isBinary", types.isBinary);
|
|
goog.exportSymbol("transit.uri", types.uri);
|
|
goog.exportSymbol("transit.isURI", types.isURI);
|
|
goog.exportSymbol("transit.map", types.map);
|
|
goog.exportSymbol("transit.isMap", types.isMap);
|
|
goog.exportSymbol("transit.set", types.set);
|
|
goog.exportSymbol("transit.isSet", types.isSet);
|
|
goog.exportSymbol("transit.list", types.list);
|
|
goog.exportSymbol("transit.isList", types.isList);
|
|
goog.exportSymbol("transit.quoted", types.quoted);
|
|
goog.exportSymbol("transit.isQuoted", types.isQuoted);
|
|
goog.exportSymbol("transit.tagged", types.taggedValue);
|
|
goog.exportSymbol("transit.isTaggedValue", types.isTaggedValue);
|
|
goog.exportSymbol("transit.link", types.link);
|
|
goog.exportSymbol("transit.isLink", types.isLink);
|
|
goog.exportSymbol("transit.hash", eq.hashCode);
|
|
goog.exportSymbol("transit.hashMapLike", eq.hashMapLike);
|
|
goog.exportSymbol("transit.hashArrayLike", eq.hashArrayLike);
|
|
goog.exportSymbol("transit.equals", eq.equals);
|
|
goog.exportSymbol("transit.extendToEQ", eq.extendToEQ);
|
|
goog.exportSymbol("transit.mapToObject", transit.mapToObject);
|
|
goog.exportSymbol("transit.objectToMap", transit.objectToMap);
|
|
goog.exportSymbol("transit.decoder", decoder.decoder);
|
|
goog.exportSymbol("transit.UUIDfromString", types.UUIDfromString);
|
|
goog.exportSymbol("transit.randomUUID", util.randomUUID);
|
|
goog.exportSymbol("transit.stringableKeys", writer.stringableKeys);
|
|
goog.exportSymbol("transit.readCache", caching.readCache);
|
|
goog.exportSymbol("transit.writeCache", caching.writeCache);
|
|
}
|
|
|
|
if(TRANSIT_NODE_TARGET) {
|
|
module.exports = {
|
|
reader: transit.reader,
|
|
writer: transit.writer,
|
|
makeBuilder: transit.makeBuilder,
|
|
makeWriteHandler: transit.makeWriteHandler,
|
|
date: types.date,
|
|
integer: types.intValue,
|
|
isInteger: types.isInteger,
|
|
uuid: types.uuid,
|
|
isUUID: types.isUUID,
|
|
bigInt: types.bigInteger,
|
|
isBigInt: types.isBigInteger,
|
|
bigDec: types.bigDecimalValue,
|
|
isBigDec: types.isBigDecimal,
|
|
keyword: types.keyword,
|
|
isKeyword: types.isKeyword,
|
|
symbol: types.symbol,
|
|
isSymbol: types.isSymbol,
|
|
binary: types.binary,
|
|
isBinary: types.isBinary,
|
|
uri: types.uri,
|
|
isURI: types.isURI,
|
|
map: types.map,
|
|
isMap: types.isMap,
|
|
set: types.set,
|
|
isSet: types.isSet,
|
|
list: types.list,
|
|
isList: types.isList,
|
|
quoted: types.quoted,
|
|
isQuoted: types.isQuoted,
|
|
tagged: types.taggedValue,
|
|
isTaggedValue: types.isTaggedValue,
|
|
link: types.link,
|
|
isLink: types.isLink,
|
|
hash: eq.hashCode,
|
|
hashArrayLike: eq.hashArrayLike,
|
|
hashMapLike: eq.hashMapLike,
|
|
equals: eq.equals,
|
|
extendToEQ: eq.extendToEQ,
|
|
mapToObject: transit.mapToObject,
|
|
objectToMap: transit.objectToMap,
|
|
decoder: decoder.decoder,
|
|
UUIDfromString: types.UUIDfromString,
|
|
randomUUID: util.randomUUID,
|
|
stringableKeys: writer.stringableKeys,
|
|
readCache: caching.readCache,
|
|
writeCache: caching.writeCache
|
|
};
|
|
}
|
|
});
|