Elm.Native.Json = {};
Elm.Native.Json.make = function(localRuntime) {
localRuntime.Native = localRuntime.Native || {};
localRuntime.Native.Json = localRuntime.Native.Json || {};
if (localRuntime.Native.Json.values) {
return localRuntime.Native.Json.values;
}
var ElmArray = Elm.Native.Array.make(localRuntime);
var List = Elm.Native.List.make(localRuntime);
var Maybe = Elm.Maybe.make(localRuntime);
var Result = Elm.Result.make(localRuntime);
var Utils = Elm.Native.Utils.make(localRuntime);
function crash(expected, actual) {
throw new Error(
'expecting ' + expected + ' but got ' + JSON.stringify(actual)
);
}
// PRIMITIVE VALUES
function decodeNull(successValue) {
return function(value) {
if (value === null) {
return successValue;
}
crash('null', value);
};
}
function decodeString(value) {
if (typeof value === 'string' || value instanceof String) {
return value;
}
crash('a String', value);
}
function decodeFloat(value) {
if (typeof value === 'number') {
return value;
}
crash('a Float', value);
}
function decodeInt(value) {
if (typeof value === 'number' && (value|0) === value) {
return value;
}
crash('an Int', value);
}
function decodeBool(value) {
if (typeof value === 'boolean') {
return value;
}
crash('a Bool', value);
}
// ARRAY
function decodeArray(decoder) {
return function(value) {
if (value instanceof Array) {
var len = value.length;
var array = new Array(len);
for (var i = len; i-- ; ) {
array[i] = decoder(value[i]);
}
return ElmArray.fromJSArray(array);
}
crash('an Array', value);
};
}
// LIST
function decodeList(decoder) {
return function(value) {
if (value instanceof Array) {
var len = value.length;
var list = List.Nil;
for (var i = len; i-- ; ) {
list = List.Cons( decoder(value[i]), list );
}
return list;
}
crash('a List', value);
};
}
// MAYBE
function decodeMaybe(decoder) {
return function(value) {
try {
return Maybe.Just(decoder(value));
} catch(e) {
return Maybe.Nothing;
}
};
}
// FIELDS
function decodeField(field, decoder) {
return function(value) {
var subValue = value[field];
if (subValue !== undefined) {
return decoder(subValue);
}
crash("an object with field '" + field + "'", value);
};
}
// OBJECTS
function decodeKeyValuePairs(decoder) {
return function(value) {
var isObject =
typeof value === 'object'
&& value !== null
&& !(value instanceof Array);
if (isObject) {
var keyValuePairs = List.Nil;
for (var key in value) {
var elmValue = decoder(value[key]);
var pair = Utils.Tuple2(key, elmValue);
keyValuePairs = List.Cons(pair, keyValuePairs);
}
return keyValuePairs;
}
crash("an object", value);
};
}
function decodeObject1(f, d1) {
return function(value) {
return f(d1(value));
};
}
function decodeObject2(f, d1, d2) {
return function(value) {
return A2( f, d1(value), d2(value) );
};
}
function decodeObject3(f, d1, d2, d3) {
return function(value) {
return A3( f, d1(value), d2(value), d3(value) );
};
}
function decodeObject4(f, d1, d2, d3, d4) {
return function(value) {
return A4( f, d1(value), d2(value), d3(value), d4(value) );
};
}
function decodeObject5(f, d1, d2, d3, d4, d5) {
return function(value) {
return A5( f, d1(value), d2(value), d3(value), d4(value), d5(value) );
};
}
function decodeObject6(f, d1, d2, d3, d4, d5, d6) {
return function(value) {
return A6( f,
d1(value),
d2(value),
d3(value),
d4(value),
d5(value),
d6(value)
);
};
}
function decodeObject7(f, d1, d2, d3, d4, d5, d6, d7) {
return function(value) {
return A7( f,
d1(value),
d2(value),
d3(value),
d4(value),
d5(value),
d6(value),
d7(value)
);
};
}
function decodeObject8(f, d1, d2, d3, d4, d5, d6, d7, d8) {
return function(value) {
return A8( f,
d1(value),
d2(value),
d3(value),
d4(value),
d5(value),
d6(value),
d7(value),
d8(value)
);
};
}
// TUPLES
function decodeTuple1(f, d1) {
return function(value) {
if ( !(value instanceof Array) || value.length !== 1 ) {
crash('a Tuple of length 1', value);
}
return f( d1(value[0]) );
};
}
function decodeTuple2(f, d1, d2) {
return function(value) {
if ( !(value instanceof Array) || value.length !== 2 ) {
crash('a Tuple of length 2', value);
}
return A2( f, d1(value[0]), d2(value[1]) );
};
}
function decodeTuple3(f, d1, d2, d3) {
return function(value) {
if ( !(value instanceof Array) || value.length !== 3 ) {
crash('a Tuple of length 3', value);
}
return A3( f, d1(value[0]), d2(value[1]), d3(value[2]) );
};
}
function decodeTuple4(f, d1, d2, d3, d4) {
return function(value) {
if ( !(value instanceof Array) || value.length !== 4 ) {
crash('a Tuple of length 4', value);
}
return A4( f, d1(value[0]), d2(value[1]), d3(value[2]), d4(value[3]) );
};
}
function decodeTuple5(f, d1, d2, d3, d4, d5) {
return function(value) {
if ( !(value instanceof Array) || value.length !== 5 ) {
crash('a Tuple of length 5', value);
}
return A5( f,
d1(value[0]),
d2(value[1]),
d3(value[2]),
d4(value[3]),
d5(value[4])
);
};
}
function decodeTuple6(f, d1, d2, d3, d4, d5, d6) {
return function(value) {
if ( !(value instanceof Array) || value.length !== 6 ) {
crash('a Tuple of length 6', value);
}
return A6( f,
d1(value[0]),
d2(value[1]),
d3(value[2]),
d4(value[3]),
d5(value[4]),
d6(value[5])
);
};
}
function decodeTuple7(f, d1, d2, d3, d4, d5, d6, d7) {
return function(value) {
if ( !(value instanceof Array) || value.length !== 7 ) {
crash('a Tuple of length 7', value);
}
return A7( f,
d1(value[0]),
d2(value[1]),
d3(value[2]),
d4(value[3]),
d5(value[4]),
d6(value[5]),
d7(value[6])
);
};
}
function decodeTuple8(f, d1, d2, d3, d4, d5, d6, d7, d8) {
return function(value) {
if ( !(value instanceof Array) || value.length !== 8 ) {
crash('a Tuple of length 8', value);
}
return A8( f,
d1(value[0]),
d2(value[1]),
d3(value[2]),
d4(value[3]),
d5(value[4]),
d6(value[5]),
d7(value[6]),
d8(value[7])
);
};
}
// CUSTOM DECODERS
function decodeValue(value) {
return value;
}
function runDecoderValue(decoder, value) {
try {
return Result.Ok(decoder(value));
} catch(e) {
return Result.Err(e.message);
}
}
function customDecoder(decoder, callback) {
return function(value) {
var result = callback(decoder(value));
if (result.ctor === 'Err') {
throw new Error('custom decoder failed: ' + result._0);
}
return result._0;
}
}
function andThen(decode, callback) {
return function(value) {
var result = decode(value);
return callback(result)(value);
}
}
function fail(msg) {
return function(value) {
throw new Error(msg);
}
}
function succeed(successValue) {
return function(value) {
return successValue;
}
}
// ONE OF MANY
function oneOf(decoders) {
return function(value) {
var errors = [];
var temp = decoders;
while (temp.ctor !== '[]') {
try {
return temp._0(value);
} catch(e) {
errors.push(e.message);
}
temp = temp._1;
}
throw new Error('expecting one of the following:\n ' + errors.join('\n '));
}
}
function get(decoder, value) {
try {
return Result.Ok(decoder(value));
} catch(e) {
return Result.Err(e.message);
}
}
// ENCODE / DECODE
function runDecoderString(decoder, string) {
try {
return Result.Ok(decoder(JSON.parse(string)));
} catch(e) {
return Result.Err(e.message);
}
}
function encode(indentLevel, value) {
return JSON.stringify(value, null, indentLevel);
}
function identity(value) {
return value;
}
function encodeObject(keyValuePairs) {
var obj = {};
while (keyValuePairs.ctor !== '[]') {
var pair = keyValuePairs._0;
obj[pair._0] = pair._1;
keyValuePairs = keyValuePairs._1;
}
return obj;
}
return localRuntime.Native.Json.values = {
encode: F2(encode),
runDecoderString: F2(runDecoderString),
runDecoderValue: F2(runDecoderValue),
get: F2(get),
oneOf: oneOf,
decodeNull: decodeNull,
decodeInt: decodeInt,
decodeFloat: decodeFloat,
decodeString: decodeString,
decodeBool: decodeBool,
decodeMaybe: decodeMaybe,
decodeList: decodeList,
decodeArray: decodeArray,
decodeField: F2(decodeField),
decodeObject1: F2(decodeObject1),
decodeObject2: F3(decodeObject2),
decodeObject3: F4(decodeObject3),
decodeObject4: F5(decodeObject4),
decodeObject5: F6(decodeObject5),
decodeObject6: F7(decodeObject6),
decodeObject7: F8(decodeObject7),
decodeObject8: F9(decodeObject8),
decodeKeyValuePairs: decodeKeyValuePairs,
decodeTuple1: F2(decodeTuple1),
decodeTuple2: F3(decodeTuple2),
decodeTuple3: F4(decodeTuple3),
decodeTuple4: F5(decodeTuple4),
decodeTuple5: F6(decodeTuple5),
decodeTuple6: F7(decodeTuple6),
decodeTuple7: F8(decodeTuple7),
decodeTuple8: F9(decodeTuple8),
andThen: F2(andThen),
decodeValue: decodeValue,
customDecoder: F2(customDecoder),
fail: fail,
succeed: succeed,
identity: identity,
encodeNull: null,
encodeArray: ElmArray.toJSArray,
encodeList: List.toArray,
encodeObject: encodeObject
};
};