@p4ulcristian/iris-layout 0.2.0 → 0.2.2

package/dist/cljs-runtime/clojure.data.js

@@ -0,0 +1,295 @@
+import "./cljs_env.js";
+import "./cljs.core.js";
+import "./clojure.set.js";
+goog.provide('clojure.data');
+/**
+ * Internal helper for diff.
+ */
+clojure.data.atom_diff = (function clojure$data$atom_diff(a,b){
+if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(a,b)){
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,null,a], null);
+} else {
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [a,b,null], null);
+}
+});
+/**
+ * Convert an associative-by-numeric-index collection into
+ * an equivalent vector, with nil for any missing keys
+ */
+clojure.data.vectorize = (function clojure$data$vectorize(m){
+if(cljs.core.seq(m)){
+return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (result,p__8040){
+var vec__8041 = p__8040;
+var k = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__8041,(0),null);
+var v = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__8041,(1),null);
+return cljs.core.assoc.cljs$core$IFn$_invoke$arity$3(result,k,v);
+}),cljs.core.vec(cljs.core.repeat.cljs$core$IFn$_invoke$arity$2(cljs.core.apply.cljs$core$IFn$_invoke$arity$2(cljs.core.max,cljs.core.keys(m)),null)),m);
+} else {
+return null;
+}
+});
+/**
+ * Diff associative things a and b, comparing only the key k.
+ */
+clojure.data.diff_associative_key = (function clojure$data$diff_associative_key(a,b,k){
+var va = cljs.core.get.cljs$core$IFn$_invoke$arity$2(a,k);
+var vb = cljs.core.get.cljs$core$IFn$_invoke$arity$2(b,k);
+var vec__8048 = clojure.data.diff(va,vb);
+var a_STAR_ = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__8048,(0),null);
+var b_STAR_ = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__8048,(1),null);
+var ab = cljs.core.nth.cljs$core$IFn$_invoke$arity$3(vec__8048,(2),null);
+var in_a = cljs.core.contains_QMARK_(a,k);
+var in_b = cljs.core.contains_QMARK_(b,k);
+var same = ((in_a) && (((in_b) && ((((!((ab == null)))) || ((((va == null)) && ((vb == null)))))))));
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [((((in_a) && ((((!((a_STAR_ == null)))) || ((!(same)))))))?cljs.core.PersistentArrayMap.createAsIfByAssoc([k,a_STAR_]):null),((((in_b) && ((((!((b_STAR_ == null)))) || ((!(same)))))))?cljs.core.PersistentArrayMap.createAsIfByAssoc([k,b_STAR_]):null),((same)?cljs.core.PersistentArrayMap.createAsIfByAssoc([k,ab]):null)], null);
+});
+/**
+ * Diff associative things a and b, comparing only keys in ks (if supplied).
+ */
+clojure.data.diff_associative = (function clojure$data$diff_associative(var_args){
+var G__8079 = arguments.length;
+switch (G__8079) {
+case 2:
+return clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$2((arguments[(0)]),(arguments[(1)]));
+
+break;
+case 3:
+return clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$3((arguments[(0)]),(arguments[(1)]),(arguments[(2)]));
+
+break;
+default:
+throw (new Error(["Invalid arity: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(arguments.length)].join('')));
+
+}
+});
+
+(clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$2 = (function (a,b){
+return clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$3(a,b,clojure.set.union.cljs$core$IFn$_invoke$arity$2(cljs.core.keys(a),cljs.core.keys(b)));
+}));
+
+(clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$3 = (function (a,b,ks){
+return cljs.core.reduce.cljs$core$IFn$_invoke$arity$3((function (diff1,diff2){
+return cljs.core.doall.cljs$core$IFn$_invoke$arity$1(cljs.core.map.cljs$core$IFn$_invoke$arity$3(cljs.core.merge,diff1,diff2));
+}),new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,null,null], null),cljs.core.map.cljs$core$IFn$_invoke$arity$2(cljs.core.partial.cljs$core$IFn$_invoke$arity$3(clojure.data.diff_associative_key,a,b),ks));
+}));
+
+(clojure.data.diff_associative.cljs$lang$maxFixedArity = 3);
+
+clojure.data.diff_sequential = (function clojure$data$diff_sequential(a,b){
+return cljs.core.vec(cljs.core.map.cljs$core$IFn$_invoke$arity$2(clojure.data.vectorize,clojure.data.diff_associative.cljs$core$IFn$_invoke$arity$3(((cljs.core.vector_QMARK_(a))?a:cljs.core.vec(a)),((cljs.core.vector_QMARK_(b))?b:cljs.core.vec(b)),cljs.core.range.cljs$core$IFn$_invoke$arity$1((function (){var x__5087__auto__ = cljs.core.count(a);
+var y__5088__auto__ = cljs.core.count(b);
+return ((x__5087__auto__ > y__5088__auto__) ? x__5087__auto__ : y__5088__auto__);
+})()))));
+});
+clojure.data.diff_set = (function clojure$data$diff_set(a,b){
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [cljs.core.not_empty(clojure.set.difference.cljs$core$IFn$_invoke$arity$2(a,b)),cljs.core.not_empty(clojure.set.difference.cljs$core$IFn$_invoke$arity$2(b,a)),cljs.core.not_empty(clojure.set.intersection.cljs$core$IFn$_invoke$arity$2(a,b))], null);
+});
+
+/**
+ * Implementation detail. Subject to change.
+ * @interface
+ */
+clojure.data.EqualityPartition = function(){};
+
+var clojure$data$EqualityPartition$equality_partition$dyn_8190 = (function (x){
+var x__5350__auto__ = (((x == null))?null:x);
+var m__5351__auto__ = (clojure.data.equality_partition[goog.typeOf(x__5350__auto__)]);
+if((!((m__5351__auto__ == null)))){
+return (m__5351__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__5351__auto__.call(null,x));
+} else {
+var m__5349__auto__ = (clojure.data.equality_partition["_"]);
+if((!((m__5349__auto__ == null)))){
+return (m__5349__auto__.cljs$core$IFn$_invoke$arity$1 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$1(x) : m__5349__auto__.call(null,x));
+} else {
+throw cljs.core.missing_protocol("EqualityPartition.equality-partition",x);
+}
+}
+});
+/**
+ * Implementation detail. Subject to change.
+ */
+clojure.data.equality_partition = (function clojure$data$equality_partition(x){
+if((((!((x == null)))) && ((!((x.clojure$data$EqualityPartition$equality_partition$arity$1 == null)))))){
+return x.clojure$data$EqualityPartition$equality_partition$arity$1(x);
+} else {
+return clojure$data$EqualityPartition$equality_partition$dyn_8190(x);
+}
+});
+
+
+/**
+ * Implementation detail. Subject to change.
+ * @interface
+ */
+clojure.data.Diff = function(){};
+
+var clojure$data$Diff$diff_similar$dyn_8245 = (function (a,b){
+var x__5350__auto__ = (((a == null))?null:a);
+var m__5351__auto__ = (clojure.data.diff_similar[goog.typeOf(x__5350__auto__)]);
+if((!((m__5351__auto__ == null)))){
+return (m__5351__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5351__auto__.cljs$core$IFn$_invoke$arity$2(a,b) : m__5351__auto__.call(null,a,b));
+} else {
+var m__5349__auto__ = (clojure.data.diff_similar["_"]);
+if((!((m__5349__auto__ == null)))){
+return (m__5349__auto__.cljs$core$IFn$_invoke$arity$2 ? m__5349__auto__.cljs$core$IFn$_invoke$arity$2(a,b) : m__5349__auto__.call(null,a,b));
+} else {
+throw cljs.core.missing_protocol("Diff.diff-similar",a);
+}
+}
+});
+/**
+ * Implementation detail. Subject to change.
+ */
+clojure.data.diff_similar = (function clojure$data$diff_similar(a,b){
+if((((!((a == null)))) && ((!((a.clojure$data$Diff$diff_similar$arity$2 == null)))))){
+return a.clojure$data$Diff$diff_similar$arity$2(a,b);
+} else {
+return clojure$data$Diff$diff_similar$dyn_8245(a,b);
+}
+});
+
+(clojure.data.EqualityPartition["null"] = true);
+
+(clojure.data.equality_partition["null"] = (function (x){
+return new cljs.core.Keyword(null,"atom","atom",-397043653);
+}));
+
+(clojure.data.EqualityPartition["string"] = true);
+
+(clojure.data.equality_partition["string"] = (function (x){
+return new cljs.core.Keyword(null,"atom","atom",-397043653);
+}));
+
+(clojure.data.EqualityPartition["number"] = true);
+
+(clojure.data.equality_partition["number"] = (function (x){
+return new cljs.core.Keyword(null,"atom","atom",-397043653);
+}));
+
+(clojure.data.EqualityPartition["array"] = true);
+
+(clojure.data.equality_partition["array"] = (function (x){
+return new cljs.core.Keyword(null,"sequential","sequential",-1082983960);
+}));
+
+(clojure.data.EqualityPartition["function"] = true);
+
+(clojure.data.equality_partition["function"] = (function (x){
+return new cljs.core.Keyword(null,"atom","atom",-397043653);
+}));
+
+(clojure.data.EqualityPartition["boolean"] = true);
+
+(clojure.data.equality_partition["boolean"] = (function (x){
+return new cljs.core.Keyword(null,"atom","atom",-397043653);
+}));
+
+(clojure.data.EqualityPartition["_"] = true);
+
+(clojure.data.equality_partition["_"] = (function (x){
+if((((!((x == null))))?(((((x.cljs$lang$protocol_mask$partition0$ & (1024))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$IMap$))))?true:(((!x.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.IMap,x):false)):cljs.core.native_satisfies_QMARK_(cljs.core.IMap,x))){
+return new cljs.core.Keyword(null,"map","map",1371690461);
+} else {
+if((((!((x == null))))?(((((x.cljs$lang$protocol_mask$partition0$ & (4096))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$ISet$))))?true:(((!x.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.ISet,x):false)):cljs.core.native_satisfies_QMARK_(cljs.core.ISet,x))){
+return new cljs.core.Keyword(null,"set","set",304602554);
+} else {
+if((((!((x == null))))?(((((x.cljs$lang$protocol_mask$partition0$ & (16777216))) || ((cljs.core.PROTOCOL_SENTINEL === x.cljs$core$ISequential$))))?true:(((!x.cljs$lang$protocol_mask$partition0$))?cljs.core.native_satisfies_QMARK_(cljs.core.ISequential,x):false)):cljs.core.native_satisfies_QMARK_(cljs.core.ISequential,x))){
+return new cljs.core.Keyword(null,"sequential","sequential",-1082983960);
+} else {
+return new cljs.core.Keyword(null,"atom","atom",-397043653);
+
+}
+}
+}
+}));
+(clojure.data.Diff["null"] = true);
+
+(clojure.data.diff_similar["null"] = (function (a,b){
+return clojure.data.atom_diff(a,b);
+}));
+
+(clojure.data.Diff["string"] = true);
+
+(clojure.data.diff_similar["string"] = (function (a,b){
+return clojure.data.atom_diff(a,b);
+}));
+
+(clojure.data.Diff["number"] = true);
+
+(clojure.data.diff_similar["number"] = (function (a,b){
+return clojure.data.atom_diff(a,b);
+}));
+
+(clojure.data.Diff["array"] = true);
+
+(clojure.data.diff_similar["array"] = (function (a,b){
+return clojure.data.diff_sequential(a,b);
+}));
+
+(clojure.data.Diff["function"] = true);
+
+(clojure.data.diff_similar["function"] = (function (a,b){
+return clojure.data.atom_diff(a,b);
+}));
+
+(clojure.data.Diff["boolean"] = true);
+
+(clojure.data.diff_similar["boolean"] = (function (a,b){
+return clojure.data.atom_diff(a,b);
+}));
+
+(clojure.data.Diff["_"] = true);
+
+(clojure.data.diff_similar["_"] = (function (a,b){
+var fexpr__8162 = (function (){var G__8163 = clojure.data.equality_partition(a);
+var G__8163__$1 = (((G__8163 instanceof cljs.core.Keyword))?G__8163.fqn:null);
+switch (G__8163__$1) {
+case "atom":
+return clojure.data.atom_diff;
+
+break;
+case "set":
+return clojure.data.diff_set;
+
+break;
+case "sequential":
+return clojure.data.diff_sequential;
+
+break;
+case "map":
+return clojure.data.diff_associative;
+
+break;
+default:
+throw (new Error(["No matching clause: ",cljs.core.str.cljs$core$IFn$_invoke$arity$1(G__8163__$1)].join('')));
+
+}
+})();
+return (fexpr__8162.cljs$core$IFn$_invoke$arity$2 ? fexpr__8162.cljs$core$IFn$_invoke$arity$2(a,b) : fexpr__8162.call(null,a,b));
+}));
+/**
+ * Recursively compares a and b, returning a tuple of
+ *   [things-only-in-a things-only-in-b things-in-both].
+ *   Comparison rules:
+ * 
+ *   * For equal a and b, return [nil nil a].
+ *   * Maps are subdiffed where keys match and values differ.
+ *   * Sets are never subdiffed.
+ *   * All sequential things are treated as associative collections
+ *  by their indexes, with results returned as vectors.
+ *   * Everything else (including strings!) is treated as
+ *  an atom and compared for equality.
+ */
+clojure.data.diff = (function clojure$data$diff(a,b){
+if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(a,b)){
+return new cljs.core.PersistentVector(null, 3, 5, cljs.core.PersistentVector.EMPTY_NODE, [null,null,a], null);
+} else {
+if(cljs.core._EQ_.cljs$core$IFn$_invoke$arity$2(clojure.data.equality_partition(a),clojure.data.equality_partition(b))){
+return clojure.data.diff_similar(a,b);
+} else {
+return clojure.data.atom_diff(a,b);
+}
+}
+});
+
+//# sourceMappingURL=clojure.data.js.map

package/dist/cljs-runtime/clojure.data.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["clojure/data.cljs"],"mappings":"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","names":["clojure.data/atom-diff","a","b","cljs.core._EQ_","clojure.data/vectorize","m","cljs.core/seq","cljs.core.reduce","p__8040","vec__8041","cljs.core.nth","result","k","v","cljs.core.assoc","cljs.core/vec","cljs.core.repeat","cljs.core.apply","cljs.core/max","cljs.core/keys","clojure.data/diff-associative-key","vec__8048","va","cljs.core.get","vb","a*","b*","ab","clojure.data/diff","in-a","cljs.core/contains?","in-b","same","var_args","G__8079","clojure.data/diff-associative","js/Error","clojure.data.diff_associative","clojure.set.union","ks","diff1","diff2","cljs.core.doall","cljs.core.map","cljs.core/merge","cljs.core.partial","clojure.data/diff-sequential","cljs.core/vector?","cljs.core.range","x__5087__auto__","y__5088__auto__","cljs.core/count","clojure.data/diff-set","cljs.core/not-empty","clojure.set.difference","clojure.set.intersection","clojure$data$EqualityPartition$equality_partition$dyn","x__5350__auto__","m__5351__auto__","clojure.data/equality-partition","goog/typeOf","m__5349__auto__","cljs.core/missing-protocol","clojure.data/EqualityPartition","x","clojure$data$Diff$diff_similar$dyn","clojure.data/diff-similar","clojure.data/Diff","cljs.core/PROTOCOL_SENTINEL","cljs.core/native-satisfies?","cljs.core/IMap","cljs.core/ISet","cljs.core/ISequential","fexpr__8162","G__8163","cljs.core/Keyword"],"sourcesContent":[";   Copyright (c) Rich Hickey. All rights reserved.\n;   The use and distribution terms for this software are covered by the\n;   Eclipse Public License 1.0 (http://opensource.org/licenses/eclipse-1.0.php)\n;   which can be found in the file epl-v10.html at the root of this distribution.\n;   By using this software in any fashion, you are agreeing to be bound by\n;   the terms of this license.\n;   You must not remove this notice, or any other, from this software.\n\n(ns \n  ^{:author \"Stuart Halloway\",\n    :doc \"Non-core data functions.\"}\n  clojure.data\n  (:require [clojure.set :as set]))\n\n(declare ^{:arglists '([a b])} diff)\n\n(defn- atom-diff\n  \"Internal helper for diff.\"\n  [a b]\n  (if (= a b) [nil nil a] [a b nil]))\n\n;; for big things a sparse vector class would be better\n(defn- vectorize\n  \"Convert an associative-by-numeric-index collection into\n   an equivalent vector, with nil for any missing keys\"\n  [m]\n  (when (seq m)\n    (reduce\n     (fn [result [k v]] (assoc result k v))\n     (vec (repeat (apply max (keys m))  nil))\n     m)))\n\n(defn- diff-associative-key\n  \"Diff associative things a and b, comparing only the key k.\"\n  [a b k]\n  (let [va (get a k)\n        vb (get b k)\n        [a* b* ab] (diff va vb)\n        in-a (contains? a k)\n        in-b (contains? b k)\n        same (and in-a in-b\n                  (or (not (nil? ab))\n                      (and (nil? va) (nil? vb))))]\n    [(when (and in-a (or (not (nil? a*)) (not same))) {k a*})\n     (when (and in-b (or (not (nil? b*)) (not same))) {k b*})\n     (when same {k ab})\n     ]))\n\n(defn- diff-associative\n  \"Diff associative things a and b, comparing only keys in ks (if supplied).\"\n  ([a b]\n     (diff-associative a b (set/union (keys a) (keys b))))\n  ([a b ks]\n     (reduce\n      (fn [diff1 diff2]\n        (doall (map merge diff1 diff2)))\n      [nil nil nil]\n      (map\n       (partial diff-associative-key a b)\n       ks))))\n\n(defn- diff-sequential\n  [a b]\n  (vec (map vectorize (diff-associative\n                       (if (vector? a) a (vec a))\n                       (if (vector? b) b (vec b))\n                       (range (max (count a) (count b)))))))\n\n(defn- diff-set\n  [a b]\n  [(not-empty (set/difference a b))\n   (not-empty (set/difference b a))\n   (not-empty (set/intersection a b))])\n\n(defprotocol EqualityPartition\n  \"Implementation detail. Subject to change.\"\n  (equality-partition [x] \"Implementation detail. Subject to change.\"))\n\n(defprotocol Diff\n  \"Implementation detail. Subject to change.\"\n  (diff-similar [a b] \"Implementation detail. Subject to change.\"))\n\n(extend-protocol EqualityPartition\n  nil\n  (equality-partition [x] :atom)\n\n  string\n  (equality-partition [x] :atom)\n\n  number\n  (equality-partition [x] :atom)\n\n  array\n  (equality-partition [x] :sequential)\n\n  function\n  (equality-partition [x] :atom)\n\n  boolean\n  (equality-partition [x] :atom)\n\n  default\n  (equality-partition [x]\n    (cond\n     (satisfies? IMap x) :map\n     (satisfies? ISet x) :set\n     (satisfies? ISequential x) :sequential\n     :default :atom)))\n\n(extend-protocol Diff\n  nil\n  (diff-similar [a b]\n    (atom-diff a b))\n\n  string\n  (diff-similar [a b]\n    (atom-diff a b))\n\n  number\n  (diff-similar [a b]\n    (atom-diff a b))\n\n  array\n  (diff-similar [a b]\n    (diff-sequential a b))\n\n  function\n  (diff-similar [a b]\n    (atom-diff a b))\n\n  boolean\n  (diff-similar [a b]\n    (atom-diff a b))\n\n  default\n  (diff-similar [a b]\n    ((case (equality-partition a)\n       :atom atom-diff\n       :set diff-set\n       :sequential diff-sequential\n       :map diff-associative)\n     a b)))\n\n(defn diff\n  \"Recursively compares a and b, returning a tuple of\n  [things-only-in-a things-only-in-b things-in-both].\n  Comparison rules:\n\n  * For equal a and b, return [nil nil a].\n  * Maps are subdiffed where keys match and values differ.\n  * Sets are never subdiffed.\n  * All sequential things are treated as associative collections\n    by their indexes, with results returned as vectors.\n  * Everything else (including strings!) is treated as\n    an atom and compared for equality.\"\n  [a b]\n  (if (= a b)\n    [nil nil a]\n    (if (= (equality-partition a) (equality-partition b))\n      (diff-similar a b)\n      (atom-diff a b))))\n  \n"],"x_google_ignoreList":[0]}