@yappkit/front-module-map 0.1.0

package/lib/mapbox-sdk/create-service-factory.js

@@ -0,0 +1,237 @@
+import { c as m } from "../_commonjsHelpers.js";
+import { i as h, m as V, b as N } from "./browser-client.js";
+var R = Object.prototype.toString, _ = function(r) {
+  var e;
+  return R.call(r) === "[object Object]" && (e = Object.getPrototypeOf(r), e === null || e === Object.getPrototypeOf({}));
+}, E = _, M = h, A = "value", y = `
+  `, u = {};
+u.assert = function(r, e) {
+  return e = e || {}, function(n) {
+    var t = c(r, n);
+    if (t) {
+      var a = v(t, e);
+      throw e.apiName && (a = e.apiName + ": " + a), new Error(a);
+    }
+  };
+};
+u.shape = function(e) {
+  var n = F(e);
+  return function(a) {
+    var i = c(u.plainObject, a);
+    if (i)
+      return i;
+    for (var o, s, f = [], p = 0; p < n.length; p++)
+      o = n[p].key, s = n[p].value, i = c(s, a[o]), i && f.push([o].concat(i));
+    return f.length < 2 ? f[0] : function(d) {
+      f = f.map(function(b) {
+        var S = b[0], q = v(b, d).split(`
+`).join(y);
+        return "- " + S + ": " + q;
+      });
+      var g = d.path.join("."), w = g === A ? "" : " of " + g;
+      return "The following properties" + w + " have invalid values:" + y + f.join(y);
+    };
+  };
+};
+u.strictShape = function(e) {
+  var n = u.shape(e);
+  return function(a) {
+    var i = n(a);
+    if (i)
+      return i;
+    var o = Object.keys(a).reduce(function(s, f) {
+      return e[f] === void 0 && s.push(f), s;
+    }, []);
+    if (o.length !== 0)
+      return function() {
+        return "The following keys are invalid: " + o.join(", ");
+      };
+  };
+};
+u.arrayOf = function(e) {
+  return O(e);
+};
+u.tuple = function() {
+  var e = Array.isArray(arguments[0]) ? arguments[0] : Array.prototype.slice.call(arguments);
+  return O(e);
+};
+function O(r) {
+  var e = Array.isArray(r), n = function(t) {
+    return e ? r[t] : r;
+  };
+  return function(a) {
+    var i = c(u.plainArray, a);
+    if (i)
+      return i;
+    if (e && a.length !== r.length)
+      return "an array with " + r.length + " items";
+    for (var o = 0; o < a.length; o++)
+      if (i = c(n(o), a[o]), i)
+        return [o].concat(i);
+  };
+}
+u.required = function(e) {
+  function n(t) {
+    return t == null ? function(a) {
+      return j(
+        a,
+        T(a.path) ? "cannot be undefined/null." : "is required."
+      );
+    } : e.apply(this, arguments);
+  }
+  return n.__required = !0, n;
+};
+u.oneOfType = function() {
+  var e = Array.isArray(arguments[0]) ? arguments[0] : Array.prototype.slice.call(arguments);
+  return function(t) {
+    var a = e.map(function(i) {
+      return c(i, t);
+    }).filter(Boolean);
+    if (a.length === e.length)
+      return a.every(function(i) {
+        return i.length === 1 && typeof i[0] == "string";
+      }) ? k(
+        a.map(function(i) {
+          return i[0];
+        })
+      ) : a.reduce(function(i, o) {
+        return o.length > i.length ? o : i;
+      });
+  };
+};
+u.equal = function(e) {
+  return function(t) {
+    if (t !== e)
+      return JSON.stringify(e);
+  };
+};
+u.oneOf = function() {
+  var e = Array.isArray(arguments[0]) ? arguments[0] : Array.prototype.slice.call(arguments), n = e.map(function(t) {
+    return u.equal(t);
+  });
+  return u.oneOfType.apply(this, n);
+};
+u.range = function(e) {
+  var n = e[0], t = e[1];
+  return function(i) {
+    var o = c(u.number, i);
+    if (o || i < n || i > t)
+      return "number between " + n + " & " + t + " (inclusive)";
+  };
+};
+u.any = function() {
+};
+u.boolean = function(e) {
+  if (typeof e != "boolean")
+    return "boolean";
+};
+u.number = function(e) {
+  if (typeof e != "number")
+    return "number";
+};
+u.plainArray = function(e) {
+  if (!Array.isArray(e))
+    return "array";
+};
+u.plainObject = function(e) {
+  if (!E(e))
+    return "object";
+};
+u.string = function(e) {
+  if (typeof e != "string")
+    return "string";
+};
+u.func = function(e) {
+  if (typeof e != "function")
+    return "function";
+};
+function c(r, e) {
+  if (!(e == null && !r.hasOwnProperty("__required"))) {
+    var n = r(e);
+    if (n)
+      return Array.isArray(n) ? n : [n];
+  }
+}
+function v(r, e) {
+  var n = r.length, t = r[n - 1], a = r.slice(0, n - 1);
+  return a.length === 0 && (a = [A]), e = M(e, { path: a }), typeof t == "function" ? t(e) : j(e, B(t));
+}
+function k(r) {
+  return r.length < 2 ? r[0] : r.length === 2 ? r.join(" or ") : r.slice(0, -1).join(", ") + ", or " + r.slice(-1);
+}
+function B(r) {
+  return "must be " + C(r) + ".";
+}
+function C(r) {
+  return /^an? /.test(r) ? r : /^[aeiou]/i.test(r) ? "an " + r : /^[a-z]/i.test(r) ? "a " + r : r;
+}
+function j(r, e) {
+  var n = T(r.path), t = r.path.join(".") + " " + e, a = n ? "Item at position " : "";
+  return a + t;
+}
+function T(r) {
+  return typeof r[r.length - 1] == "number" || typeof r[0] == "number";
+}
+function F(r) {
+  return Object.keys(r || {}).map(function(e) {
+    return { key: e, value: r[e] };
+  });
+}
+u.validate = c;
+u.processMessage = v;
+var I = u, x = h, l = I;
+function D(r) {
+  if (typeof window < "u")
+    return r instanceof m.Blob || r instanceof m.ArrayBuffer ? void 0 : "Blob or ArrayBuffer";
+  if (!(typeof r == "string" || r.pipe !== void 0))
+    return "Filename or Readable stream";
+}
+function L(r, e) {
+  return l.assert(l.strictShape(r), e);
+}
+function P(r) {
+  var e = "date";
+  if (typeof r == "boolean")
+    return e;
+  try {
+    var n = new Date(r);
+    if (n.getTime && isNaN(n.getTime()))
+      return e;
+  } catch {
+    return e;
+  }
+}
+function $(r) {
+  return l.tuple(l.number, l.number)(r);
+}
+var Q = x(l, {
+  file: D,
+  date: P,
+  coordinates: $,
+  assertShape: L
+});
+function z(r, e) {
+  var n = function(t, a) {
+    return e.indexOf(t) !== -1 && a !== void 0;
+  };
+  return typeof e == "function" && (n = e), Object.keys(r).filter(function(t) {
+    return n(t, r[t]);
+  }).reduce(function(t, a) {
+    return t[a] = r[a], t;
+  }, {});
+}
+var X = z, G = V, H = N;
+function J(r) {
+  return function(e) {
+    var n;
+    G.prototype.isPrototypeOf(e) ? n = e : n = H(e);
+    var t = Object.create(r);
+    return t.client = n, t;
+  };
+}
+var Y = J;
+export {
+  Y as c,
+  X as p,
+  Q as v
+};

package/lib/mapbox-sdk/datasets.js

@@ -0,0 +1,123 @@
+import { g as p } from "../_commonjsHelpers.js";
+import { c as h, v as c, p as I } from "./create-service-factory.js";
+function m(t, n) {
+  for (var i = 0; i < n.length; i++) {
+    const s = n[i];
+    if (typeof s != "string" && !Array.isArray(s)) {
+      for (const d in s)
+        if (d !== "default" && !(d in t)) {
+          const u = Object.getOwnPropertyDescriptor(s, d);
+          u && Object.defineProperty(t, d, u.get ? u : {
+            enumerable: !0,
+            get: () => s[d]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(t, Symbol.toStringTag, { value: "Module" }));
+}
+var e = c, r = I, f = h, a = {};
+a.listDatasets = function(t) {
+  return e.assertShape({
+    sortby: e.oneOf("created", "modified")
+  })(t), this.client.createRequest({
+    method: "GET",
+    path: "/datasets/v1/:ownerId",
+    query: t ? r(t, ["sortby"]) : {}
+  });
+};
+a.createDataset = function(t) {
+  return e.assertShape({
+    name: e.string,
+    description: e.string
+  })(t), this.client.createRequest({
+    method: "POST",
+    path: "/datasets/v1/:ownerId",
+    body: t
+  });
+};
+a.getMetadata = function(t) {
+  return e.assertShape({
+    datasetId: e.required(e.string),
+    description: e.string
+  })(t), this.client.createRequest({
+    method: "GET",
+    path: "/datasets/v1/:ownerId/:datasetId",
+    params: t
+  });
+};
+a.updateMetadata = function(t) {
+  return e.assertShape({
+    datasetId: e.required(e.string),
+    name: e.string,
+    description: e.string
+  })(t), this.client.createRequest({
+    method: "PATCH",
+    path: "/datasets/v1/:ownerId/:datasetId",
+    params: r(t, ["datasetId"]),
+    body: r(t, ["name", "description"])
+  });
+};
+a.deleteDataset = function(t) {
+  return e.assertShape({
+    datasetId: e.required(e.string)
+  })(t), this.client.createRequest({
+    method: "DELETE",
+    path: "/datasets/v1/:ownerId/:datasetId",
+    params: t
+  });
+};
+a.listFeatures = function(t) {
+  return e.assertShape({
+    datasetId: e.required(e.string),
+    limit: e.number,
+    start: e.string
+  })(t), this.client.createRequest({
+    method: "GET",
+    path: "/datasets/v1/:ownerId/:datasetId/features",
+    params: r(t, ["datasetId"]),
+    query: r(t, ["limit", "start"])
+  });
+};
+a.putFeature = function(t) {
+  if (e.assertShape({
+    datasetId: e.required(e.string),
+    featureId: e.required(e.string),
+    feature: e.required(e.plainObject)
+  })(t), t.feature.id !== void 0 && t.feature.id !== t.featureId)
+    throw new Error("featureId must match the id property of the feature");
+  return this.client.createRequest({
+    method: "PUT",
+    path: "/datasets/v1/:ownerId/:datasetId/features/:featureId",
+    params: r(t, ["datasetId", "featureId"]),
+    body: t.feature
+  });
+};
+a.getFeature = function(t) {
+  return e.assertShape({
+    datasetId: e.required(e.string),
+    featureId: e.required(e.string)
+  })(t), this.client.createRequest({
+    method: "GET",
+    path: "/datasets/v1/:ownerId/:datasetId/features/:featureId",
+    params: t
+  });
+};
+a.deleteFeature = function(t) {
+  return e.assertShape({
+    datasetId: e.required(e.string),
+    featureId: e.required(e.string)
+  })(t), this.client.createRequest({
+    method: "DELETE",
+    path: "/datasets/v1/:ownerId/:datasetId/features/:featureId",
+    params: t
+  });
+};
+var o = f(a);
+const l = /* @__PURE__ */ p(o), y = /* @__PURE__ */ m({
+  __proto__: null,
+  default: l
+}, [o]);
+export {
+  y as d
+};

package/lib/mapbox-sdk/directions.js

@@ -0,0 +1,155 @@
+import { g as c } from "../_commonjsHelpers.js";
+import { c as u, v } from "./create-service-factory.js";
+import { o as g } from "./object-clean.js";
+import { s as m } from "./stringify-booleans.js";
+function d(r, a) {
+  for (var o = 0; o < a.length; o++) {
+    const i = a[o];
+    if (typeof i != "string" && !Array.isArray(i)) {
+      for (const t in i)
+        if (t !== "default" && !(t in r)) {
+          const n = Object.getOwnPropertyDescriptor(i, t);
+          n && Object.defineProperty(r, t, n.get ? n : {
+            enumerable: !0,
+            get: () => i[t]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var e = v, h = u, l = g, p = m, s = {};
+s.getDirections = function(r) {
+  e.assertShape({
+    profile: e.oneOf("driving-traffic", "driving", "walking", "cycling"),
+    waypoints: e.required(
+      e.arrayOf(
+        e.shape({
+          coordinates: e.required(e.coordinates),
+          approach: e.oneOf("unrestricted", "curb"),
+          bearing: e.arrayOf(e.range([0, 360])),
+          radius: e.oneOfType(e.number, e.equal("unlimited")),
+          waypointName: e.string
+        })
+      )
+    ),
+    alternatives: e.boolean,
+    annotations: e.arrayOf(
+      e.oneOf(
+        "duration",
+        "distance",
+        "speed",
+        "congestion",
+        "congestion_numeric",
+        "max_speed",
+        "closure",
+        "state_of_charge"
+      )
+    ),
+    bannerInstructions: e.boolean,
+    continueStraight: e.boolean,
+    exclude: e.string,
+    geometries: e.string,
+    language: e.string,
+    overview: e.string,
+    roundaboutExits: e.boolean,
+    steps: e.boolean,
+    voiceInstructions: e.boolean,
+    voiceUnits: e.string,
+    engine: e.string,
+    ev_initial_charge: e.number,
+    ev_max_charge: e.number,
+    ev_connector_types: e.string,
+    energy_consumption_curve: e.string,
+    ev_charging_curve: e.string,
+    ev_unconditioned_charging_curve: e.string,
+    ev_pre_conditioning_time: e.number,
+    ev_max_ac_charging_power: e.number,
+    ev_min_charge_at_destination: e.number,
+    ev_min_charge_at_charging_station: e.number,
+    auxiliary_consumption: e.number,
+    maxHeight: e.number,
+    maxWidth: e.number,
+    maxWeight: e.number,
+    notifications: e.string,
+    departAt: e.string,
+    arriveBy: e.string
+  })(r), r.profile = r.profile || "driving";
+  var a = {
+    coordinates: [],
+    approach: [],
+    bearing: [],
+    radius: [],
+    waypointName: []
+  }, o = r.waypoints.length;
+  if (o < 2 || o > 25)
+    throw new Error(
+      "waypoints must include between 2 and 25 DirectionsWaypoints"
+    );
+  r.waypoints.forEach(function(t) {
+    a.coordinates.push(
+      t.coordinates[0] + "," + t.coordinates[1]
+    ), ["bearing"].forEach(function(n) {
+      t.hasOwnProperty(n) && t[n] != null && (t[n] = t[n].join(","));
+    }), ["approach", "bearing", "radius", "waypointName"].forEach(function(n) {
+      t.hasOwnProperty(n) && t[n] != null ? a[n].push(t[n]) : a[n].push("");
+    });
+  }), ["approach", "bearing", "radius", "waypointName"].forEach(function(t) {
+    a[t].every(function(n) {
+      return n === "";
+    }) ? delete a[t] : a[t] = a[t].join(";");
+  });
+  var i = p({
+    alternatives: r.alternatives,
+    annotations: r.annotations,
+    banner_instructions: r.bannerInstructions,
+    continue_straight: r.continueStraight,
+    exclude: r.exclude,
+    geometries: r.geometries,
+    language: r.language,
+    overview: r.overview,
+    roundabout_exits: r.roundaboutExits,
+    steps: r.steps,
+    voice_instructions: r.voiceInstructions,
+    voice_units: r.voiceUnits,
+    approaches: a.approach,
+    bearings: a.bearing,
+    radiuses: a.radius,
+    waypoint_names: a.waypointName,
+    engine: r.engine,
+    ev_initial_charge: r.ev_initial_charge,
+    ev_max_charge: r.ev_max_charge,
+    ev_connector_types: r.ev_connector_types,
+    energy_consumption_curve: r.energy_consumption_curve,
+    ev_charging_curve: r.ev_charging_curve,
+    ev_unconditioned_charging_curve: r.ev_unconditioned_charging_curve,
+    ev_pre_conditioning_time: r.ev_pre_conditioning_time,
+    ev_max_ac_charging_power: r.ev_max_ac_charging_power,
+    ev_min_charge_at_destination: r.ev_min_charge_at_destination,
+    ev_min_charge_at_charging_station: r.ev_min_charge_at_charging_station,
+    auxiliary_consumption: r.auxiliary_consumption,
+    max_height: r.maxHeight,
+    max_width: r.maxWidth,
+    max_weight: r.maxWeight,
+    notifications: r.notifications,
+    depart_at: r.departAt,
+    arrive_by: r.arriveBy
+  });
+  return this.client.createRequest({
+    method: "GET",
+    path: "/directions/v5/mapbox/:profile/:coordinates",
+    params: {
+      profile: r.profile,
+      coordinates: a.coordinates.join(";")
+    },
+    query: l(i)
+  });
+};
+var _ = h(s);
+const b = /* @__PURE__ */ c(_), O = /* @__PURE__ */ d({
+  __proto__: null,
+  default: b
+}, [_]);
+export {
+  O as d
+};

package/lib/mapbox-sdk/geocoding-v6.js

@@ -0,0 +1,129 @@
+import { g as m } from "../_commonjsHelpers.js";
+import { i as p } from "./browser-client.js";
+import { c as y, v as b, p as v } from "./create-service-factory.js";
+import { s as f } from "./stringify-booleans.js";
+function h(r, t) {
+  for (var n = 0; n < t.length; n++) {
+    const o = t[n];
+    if (typeof o != "string" && !Array.isArray(o)) {
+      for (const a in o)
+        if (a !== "default" && !(a in r)) {
+          const s = Object.getOwnPropertyDescriptor(o, a);
+          s && Object.defineProperty(r, a, s.get ? s : {
+            enumerable: !0,
+            get: () => o[a]
+          });
+        }
+    }
+  }
+  return Object.freeze(Object.defineProperty(r, Symbol.toStringTag, { value: "Module" }));
+}
+var i = p, e = b, d = v, l = f, O = y, u = {}, c = [
+  "street",
+  "country",
+  "region",
+  "postcode",
+  "district",
+  "place",
+  "locality",
+  "neighborhood",
+  "address"
+];
+u.forwardGeocode = function(r) {
+  r.mode = r.mode || "standard", e.assertShape(
+    i(r.mode === "standard" ? { query: e.required(e.string) } : {}, {
+      mode: e.oneOf("standard", "structured"),
+      countries: r.mode === "standard" ? e.arrayOf(e.string) : e.string,
+      proximity: e.oneOf(e.coordinates, "ip"),
+      types: e.arrayOf(e.oneOf(c)),
+      bbox: e.arrayOf(e.number),
+      format: e.oneOf("geojson", "v5"),
+      language: e.string,
+      limit: e.number,
+      worldview: e.string,
+      autocomplete: e.boolean,
+      permanent: e.boolean,
+      // structured input fields
+      address_line1: e.string,
+      address_number: e.string,
+      street: e.string,
+      block: e.string,
+      place: e.string,
+      region: e.string,
+      neighborhood: e.string,
+      postcode: e.string,
+      locality: e.string
+    })
+  )(r);
+  var t = l(
+    i(
+      r.mode === "standard" ? { q: r.query } : d(r, [
+        "address_line1",
+        "address_number",
+        "street",
+        "block",
+        "place",
+        "region",
+        "neighborhood",
+        "postcode",
+        "locality"
+      ]),
+      { country: r.countries },
+      d(r, [
+        "proximity",
+        "types",
+        "bbox",
+        "format",
+        "language",
+        "limit",
+        "worldview",
+        "autocomplete",
+        "permanent"
+      ])
+    )
+  );
+  return this.client.createRequest({
+    method: "GET",
+    path: "/search/geocode/v6/forward",
+    query: t
+  });
+};
+u.reverseGeocode = function(r) {
+  e.assertShape({
+    longitude: e.required(e.number),
+    latitude: e.required(e.number),
+    countries: e.arrayOf(e.string),
+    types: e.arrayOf(e.oneOf(c)),
+    limit: e.number,
+    language: e.string,
+    worldview: e.string,
+    permanent: e.boolean
+  })(r);
+  var t = l(
+    i(
+      { country: r.countries },
+      d(r, [
+        "longitude",
+        "latitude",
+        "types",
+        "limit",
+        "language",
+        "worldview",
+        "permanent"
+      ])
+    )
+  );
+  return this.client.createRequest({
+    method: "GET",
+    path: "/search/geocode/v6/reverse",
+    query: t
+  });
+};
+var g = O(u);
+const q = /* @__PURE__ */ m(g), S = /* @__PURE__ */ h({
+  __proto__: null,
+  default: q
+}, [g]);
+export {
+  S as g
+};