@artaio/arta-browser 2.0.0

package/dist/fixtures/countries.js

@@ -0,0 +1,250 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.countries = void 0;
+exports.countries = [
+    { code: 'AF', name: 'Afghanistan' },
+    { code: 'AX', name: 'Aland Islands' },
+    { code: 'AL', name: 'Albania' },
+    { code: 'DZ', name: 'Algeria' },
+    { code: 'AS', name: 'American Samoa' },
+    { code: 'AD', name: 'Andorra' },
+    { code: 'AO', name: 'Angola' },
+    { code: 'AI', name: 'Anguilla' },
+    { code: 'AQ', name: 'Antarctica' },
+    { code: 'AG', name: 'Antigua And Barbuda' },
+    { code: 'AR', name: 'Argentina' },
+    { code: 'AM', name: 'Armenia' },
+    { code: 'AW', name: 'Aruba' },
+    { code: 'AU', name: 'Australia' },
+    { code: 'AT', name: 'Austria' },
+    { code: 'AZ', name: 'Azerbaijan' },
+    { code: 'BS', name: 'Bahamas' },
+    { code: 'BH', name: 'Bahrain' },
+    { code: 'BD', name: 'Bangladesh' },
+    { code: 'BB', name: 'Barbados' },
+    { code: 'BY', name: 'Belarus' },
+    { code: 'BE', name: 'Belgium' },
+    { code: 'BZ', name: 'Belize' },
+    { code: 'BJ', name: 'Benin' },
+    { code: 'BM', name: 'Bermuda' },
+    { code: 'BT', name: 'Bhutan' },
+    { code: 'BO', name: 'Bolivia' },
+    { code: 'BA', name: 'Bosnia And Herzegovina' },
+    { code: 'BW', name: 'Botswana' },
+    { code: 'BV', name: 'Bouvet Island' },
+    { code: 'BR', name: 'Brazil' },
+    { code: 'IO', name: 'British Indian Ocean Territory' },
+    { code: 'BN', name: 'Brunei Darussalam' },
+    { code: 'BG', name: 'Bulgaria' },
+    { code: 'BF', name: 'Burkina Faso' },
+    { code: 'BI', name: 'Burundi' },
+    { code: 'KH', name: 'Cambodia' },
+    { code: 'CM', name: 'Cameroon' },
+    { code: 'CA', name: 'Canada' },
+    { code: 'CV', name: 'Cape Verde' },
+    { code: 'KY', name: 'Cayman Islands' },
+    { code: 'CF', name: 'Central African Republic' },
+    { code: 'TD', name: 'Chad' },
+    { code: 'CL', name: 'Chile' },
+    { code: 'CN', name: 'China' },
+    { code: 'CX', name: 'Christmas Island' },
+    { code: 'CC', name: 'Cocos (Keeling) Islands' },
+    { code: 'CO', name: 'Colombia' },
+    { code: 'KM', name: 'Comoros' },
+    { code: 'CG', name: 'Congo' },
+    { code: 'CD', name: 'Congo, Democratic Republic' },
+    { code: 'CK', name: 'Cook Islands' },
+    { code: 'CR', name: 'Costa Rica' },
+    { code: 'CI', name: "Cote D'Ivoire" },
+    { code: 'HR', name: 'Croatia' },
+    { code: 'CU', name: 'Cuba' },
+    { code: 'CY', name: 'Cyprus' },
+    { code: 'CZ', name: 'Czech Republic' },
+    { code: 'DK', name: 'Denmark' },
+    { code: 'DJ', name: 'Djibouti' },
+    { code: 'DM', name: 'Dominica' },
+    { code: 'DO', name: 'Dominican Republic' },
+    { code: 'EC', name: 'Ecuador' },
+    { code: 'EG', name: 'Egypt' },
+    { code: 'SV', name: 'El Salvador' },
+    { code: 'GQ', name: 'Equatorial Guinea' },
+    { code: 'ER', name: 'Eritrea' },
+    { code: 'EE', name: 'Estonia' },
+    { code: 'ET', name: 'Ethiopia' },
+    { code: 'FK', name: 'Falkland Islands (Malvinas)' },
+    { code: 'FO', name: 'Faroe Islands' },
+    { code: 'FJ', name: 'Fiji' },
+    { code: 'FI', name: 'Finland' },
+    { code: 'FR', name: 'France' },
+    { code: 'GF', name: 'French Guiana' },
+    { code: 'PF', name: 'French Polynesia' },
+    { code: 'TF', name: 'French Southern Territories' },
+    { code: 'GA', name: 'Gabon' },
+    { code: 'GM', name: 'Gambia' },
+    { code: 'GE', name: 'Georgia' },
+    { code: 'DE', name: 'Germany' },
+    { code: 'GH', name: 'Ghana' },
+    { code: 'GI', name: 'Gibraltar' },
+    { code: 'GR', name: 'Greece' },
+    { code: 'GL', name: 'Greenland' },
+    { code: 'GD', name: 'Grenada' },
+    { code: 'GP', name: 'Guadeloupe' },
+    { code: 'GU', name: 'Guam' },
+    { code: 'GT', name: 'Guatemala' },
+    { code: 'GG', name: 'Guernsey' },
+    { code: 'GN', name: 'Guinea' },
+    { code: 'GW', name: 'Guinea-Bissau' },
+    { code: 'GY', name: 'Guyana' },
+    { code: 'HT', name: 'Haiti' },
+    { code: 'HM', name: 'Heard Island & Mcdonald Islands' },
+    { code: 'VA', name: 'Holy See (Vatican City State)' },
+    { code: 'HN', name: 'Honduras' },
+    { code: 'HK', name: 'Hong Kong' },
+    { code: 'HU', name: 'Hungary' },
+    { code: 'IS', name: 'Iceland' },
+    { code: 'IN', name: 'India' },
+    { code: 'ID', name: 'Indonesia' },
+    { code: 'IR', name: 'Iran, Islamic Republic Of' },
+    { code: 'IQ', name: 'Iraq' },
+    { code: 'IE', name: 'Ireland' },
+    { code: 'IM', name: 'Isle Of Man' },
+    { code: 'IL', name: 'Israel' },
+    { code: 'IT', name: 'Italy' },
+    { code: 'JM', name: 'Jamaica' },
+    { code: 'JP', name: 'Japan' },
+    { code: 'JE', name: 'Jersey' },
+    { code: 'JO', name: 'Jordan' },
+    { code: 'KZ', name: 'Kazakhstan' },
+    { code: 'KE', name: 'Kenya' },
+    { code: 'KI', name: 'Kiribati' },
+    { code: 'KR', name: 'Korea' },
+    { code: 'KW', name: 'Kuwait' },
+    { code: 'KG', name: 'Kyrgyzstan' },
+    { code: 'LA', name: "Lao People's Democratic Republic" },
+    { code: 'LV', name: 'Latvia' },
+    { code: 'LB', name: 'Lebanon' },
+    { code: 'LS', name: 'Lesotho' },
+    { code: 'LR', name: 'Liberia' },
+    { code: 'LY', name: 'Libyan Arab Jamahiriya' },
+    { code: 'LI', name: 'Liechtenstein' },
+    { code: 'LT', name: 'Lithuania' },
+    { code: 'LU', name: 'Luxembourg' },
+    { code: 'MO', name: 'Macao' },
+    { code: 'MK', name: 'Macedonia' },
+    { code: 'MG', name: 'Madagascar' },
+    { code: 'MW', name: 'Malawi' },
+    { code: 'MY', name: 'Malaysia' },
+    { code: 'MV', name: 'Maldives' },
+    { code: 'ML', name: 'Mali' },
+    { code: 'MT', name: 'Malta' },
+    { code: 'MH', name: 'Marshall Islands' },
+    { code: 'MQ', name: 'Martinique' },
+    { code: 'MR', name: 'Mauritania' },
+    { code: 'MU', name: 'Mauritius' },
+    { code: 'YT', name: 'Mayotte' },
+    { code: 'MX', name: 'Mexico' },
+    { code: 'FM', name: 'Micronesia, Federated States Of' },
+    { code: 'MD', name: 'Moldova' },
+    { code: 'MC', name: 'Monaco' },
+    { code: 'MN', name: 'Mongolia' },
+    { code: 'ME', name: 'Montenegro' },
+    { code: 'MS', name: 'Montserrat' },
+    { code: 'MA', name: 'Morocco' },
+    { code: 'MZ', name: 'Mozambique' },
+    { code: 'MM', name: 'Myanmar' },
+    { code: 'NA', name: 'Namibia' },
+    { code: 'NR', name: 'Nauru' },
+    { code: 'NP', name: 'Nepal' },
+    { code: 'NL', name: 'Netherlands' },
+    { code: 'AN', name: 'Netherlands Antilles' },
+    { code: 'NC', name: 'New Caledonia' },
+    { code: 'NZ', name: 'New Zealand' },
+    { code: 'NI', name: 'Nicaragua' },
+    { code: 'NE', name: 'Niger' },
+    { code: 'NG', name: 'Nigeria' },
+    { code: 'NU', name: 'Niue' },
+    { code: 'NF', name: 'Norfolk Island' },
+    { code: 'MP', name: 'Northern Mariana Islands' },
+    { code: 'NO', name: 'Norway' },
+    { code: 'OM', name: 'Oman' },
+    { code: 'PK', name: 'Pakistan' },
+    { code: 'PW', name: 'Palau' },
+    { code: 'PS', name: 'Palestinian Territory, Occupied' },
+    { code: 'PA', name: 'Panama' },
+    { code: 'PG', name: 'Papua New Guinea' },
+    { code: 'PY', name: 'Paraguay' },
+    { code: 'PE', name: 'Peru' },
+    { code: 'PH', name: 'Philippines' },
+    { code: 'PN', name: 'Pitcairn' },
+    { code: 'PL', name: 'Poland' },
+    { code: 'PT', name: 'Portugal' },
+    { code: 'PR', name: 'Puerto Rico' },
+    { code: 'QA', name: 'Qatar' },
+    { code: 'RE', name: 'Reunion' },
+    { code: 'RO', name: 'Romania' },
+    { code: 'RU', name: 'Russian Federation' },
+    { code: 'RW', name: 'Rwanda' },
+    { code: 'BL', name: 'Saint Barthelemy' },
+    { code: 'SH', name: 'Saint Helena' },
+    { code: 'KN', name: 'Saint Kitts And Nevis' },
+    { code: 'LC', name: 'Saint Lucia' },
+    { code: 'MF', name: 'Saint Martin' },
+    { code: 'PM', name: 'Saint Pierre And Miquelon' },
+    { code: 'VC', name: 'Saint Vincent And Grenadines' },
+    { code: 'WS', name: 'Samoa' },
+    { code: 'SM', name: 'San Marino' },
+    { code: 'ST', name: 'Sao Tome And Principe' },
+    { code: 'SA', name: 'Saudi Arabia' },
+    { code: 'SN', name: 'Senegal' },
+    { code: 'RS', name: 'Serbia' },
+    { code: 'SC', name: 'Seychelles' },
+    { code: 'SL', name: 'Sierra Leone' },
+    { code: 'SG', name: 'Singapore' },
+    { code: 'SK', name: 'Slovakia' },
+    { code: 'SI', name: 'Slovenia' },
+    { code: 'SB', name: 'Solomon Islands' },
+    { code: 'SO', name: 'Somalia' },
+    { code: 'ZA', name: 'South Africa' },
+    { code: 'GS', name: 'South Georgia And Sandwich Isl.' },
+    { code: 'ES', name: 'Spain' },
+    { code: 'LK', name: 'Sri Lanka' },
+    { code: 'SD', name: 'Sudan' },
+    { code: 'SR', name: 'Suriname' },
+    { code: 'SJ', name: 'Svalbard And Jan Mayen' },
+    { code: 'SZ', name: 'Swaziland' },
+    { code: 'SE', name: 'Sweden' },
+    { code: 'CH', name: 'Switzerland' },
+    { code: 'SY', name: 'Syrian Arab Republic' },
+    { code: 'TW', name: 'Taiwan' },
+    { code: 'TJ', name: 'Tajikistan' },
+    { code: 'TZ', name: 'Tanzania' },
+    { code: 'TH', name: 'Thailand' },
+    { code: 'TL', name: 'Timor-Leste' },
+    { code: 'TG', name: 'Togo' },
+    { code: 'TK', name: 'Tokelau' },
+    { code: 'TO', name: 'Tonga' },
+    { code: 'TT', name: 'Trinidad And Tobago' },
+    { code: 'TN', name: 'Tunisia' },
+    { code: 'TR', name: 'Turkey' },
+    { code: 'TM', name: 'Turkmenistan' },
+    { code: 'TC', name: 'Turks And Caicos Islands' },
+    { code: 'TV', name: 'Tuvalu' },
+    { code: 'UG', name: 'Uganda' },
+    { code: 'UA', name: 'Ukraine' },
+    { code: 'AE', name: 'United Arab Emirates' },
+    { code: 'GB', name: 'United Kingdom' },
+    { code: 'US', name: 'United States' },
+    { code: 'UM', name: 'United States Outlying Islands' },
+    { code: 'UY', name: 'Uruguay' },
+    { code: 'UZ', name: 'Uzbekistan' },
+    { code: 'VU', name: 'Vanuatu' },
+    { code: 'VE', name: 'Venezuela' },
+    { code: 'VN', name: 'Viet Nam' },
+    { code: 'VG', name: 'Virgin Islands, British' },
+    { code: 'VI', name: 'Virgin Islands, U.S.' },
+    { code: 'WF', name: 'Wallis And Futuna' },
+    { code: 'EH', name: 'Western Sahara' },
+    { code: 'YE', name: 'Yemen' },
+    { code: 'ZM', name: 'Zambia' },
+    { code: 'ZW', name: 'Zimbabwe' },
+];

package/dist/helper.d.ts

@@ -0,0 +1,23 @@
+import { DestinationFullTextConfig } from './components/Destination';
+import { DisqualifiedFullTextConfig } from './components/Disqualified';
+import { QuoteFullTextConfig } from './components/Quotes';
+import { EstimateFullConfig } from './estimateConfig';
+import { ArtaLocation } from './MetadataTypes';
+export declare const parseEstimatedLocation: (loc: ArtaLocation) => string;
+export declare const parseErrors: (errors: {
+    [key: string]: string;
+}) => string[];
+export declare const getQuoteConfig: (config: EstimateFullConfig) => QuoteFullTextConfig;
+export declare const getDisqualifiedConfig: (config: EstimateFullConfig) => DisqualifiedFullTextConfig;
+export declare const getDestinationConfig: (config: EstimateFullConfig) => DestinationFullTextConfig;
+export declare const getStyle: (config: EstimateFullConfig) => {
+    '--primary-color': string;
+    '--primary-unfocused-color': string;
+    '--secondary-color': string;
+    '--error-color': string;
+    '--background-color': string;
+    '--font-family': string;
+    '--font-size': string;
+    '--width': string;
+    '--height': string;
+};

package/dist/helper.js

@@ -0,0 +1,71 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStyle = exports.getDestinationConfig = exports.getDisqualifiedConfig = exports.getQuoteConfig = exports.parseErrors = exports.parseEstimatedLocation = void 0;
+var parseEstimatedLocation = function (loc) {
+    if (!loc) {
+        return '';
+    }
+    if (!loc.estimated_country || !loc.estimated_city) {
+        return "".concat(loc.postal_code, ", ").concat(loc.country);
+    }
+    var region = loc.estimated_country === 'US' && loc.estimated_region
+        ? loc.estimated_region
+        : '';
+    var city = loc.estimated_city.toLowerCase();
+    return region === ''
+        ? "".concat(city, ", ").concat(loc.estimated_country)
+        : "".concat(city, ", ").concat(region, ", ").concat(loc.estimated_country);
+};
+exports.parseEstimatedLocation = parseEstimatedLocation;
+var parseErrors = function (errors) {
+    var errorMessages = [];
+    var keys = Object.keys(errors);
+    if (keys.includes('destination')) {
+        errorMessages.push('Invalid location details. Please check your destination address info and try again.');
+    }
+    else if (keys.includes('origin')) {
+        errorMessages.push('Invalid location details. Please check your origin address info and try again.');
+    }
+    else {
+        errorMessages.push('We have encountered an error.\nPlease try submitting the form again.');
+    }
+    return errorMessages;
+};
+exports.parseErrors = parseErrors;
+var getQuoteConfig = function (config) {
+    return __assign(__assign({}, config.text.quoted), { detailOriginLabel: config.text.detailOriginLabel, detailDestinationLabel: config.text.detailDestinationLabel, returnLinkLabel: config.text.returnLinkLabel });
+};
+exports.getQuoteConfig = getQuoteConfig;
+var getDisqualifiedConfig = function (config) {
+    return __assign(__assign({}, config.text.disqualified), { detailOriginLabel: config.text.detailOriginLabel, detailDestinationLabel: config.text.detailDestinationLabel, returnLinkLabel: config.text.returnLinkLabel });
+};
+exports.getDisqualifiedConfig = getDisqualifiedConfig;
+var getDestinationConfig = function (config) {
+    return __assign(__assign({}, config.text.destination), { detailOriginLabel: config.text.detailOriginLabel, backgroundColor: config.style.color.backgroundColor });
+};
+exports.getDestinationConfig = getDestinationConfig;
+var getStyle = function (config) {
+    return {
+        '--primary-color': config.style.color.primaryColor,
+        '--primary-unfocused-color': config.style.color.primaryUnfocusedColor,
+        '--secondary-color': config.style.color.secondaryColor,
+        '--error-color': config.style.color.errorColor,
+        '--background-color': config.style.color.backgroundColor,
+        '--font-family': config.style.fontFamily,
+        '--font-size': "".concat(config.style.fontSize, "px"),
+        '--width': "".concat(config.style.width, "px"),
+        '--height': "".concat(config.style.height, "px"),
+    };
+};
+exports.getStyle = getStyle;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import Arta from './arta';
+import './components/Modal/index.css';
+export * from './arta';
+export * from './estimate';
+declare const _default: Arta;
+export default _default;

package/dist/index.js

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var arta_1 = __importDefault(require("./arta"));
+require("./components/Modal/index.css");
+var init = function () {
+    window.Arta = new arta_1.default();
+};
+init();
+__exportStar(require("./arta"), exports);
+__exportStar(require("./estimate"), exports);
+exports.default = window.Arta;

package/dist/requests.d.ts

@@ -0,0 +1,25 @@
+import { ArtaJsFullConfig } from './arta';
+import { EstimateBody } from './estimateConfig';
+import { ArtaLocation, Insurance, Quote, SupportedCurrency } from './MetadataTypes';
+export interface HostedSession {
+    id: string;
+    private_token: string;
+    origin: ArtaLocation;
+}
+export interface QuoteRequest {
+    quotes: Quote[];
+    currency: SupportedCurrency;
+    destination: ArtaLocation;
+    origin: ArtaLocation;
+    insurance: Insurance | null;
+    err?: ArtaError;
+}
+export interface ArtaError {
+    status: number;
+    errors: {
+        [key: string]: string;
+    };
+}
+export declare const loadHostedSessions: (config: ArtaJsFullConfig, estimateBody: EstimateBody) => Promise<HostedSession>;
+export declare const loadQuoteRequests: (config: ArtaJsFullConfig, hostedSession: HostedSession, estimateBody: EstimateBody) => Promise<QuoteRequest>;
+export declare const validateEstimateBody: (config: ArtaJsFullConfig, estimateBody: EstimateBody) => Promise<boolean>;

package/dist/requests.js

@@ -0,0 +1,152 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (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;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateEstimateBody = exports.loadQuoteRequests = exports.loadHostedSessions = void 0;
+var AUTH_KEY = 'ARTA_APIKey';
+var logError = function (_a) {
+    var status = _a.status, errors = _a.errors;
+    console.log(errors);
+    var keys = Object.keys(errors);
+    if (status === 403) {
+        console.error('Invalid API Key');
+    }
+    else if (status === 401) {
+        console.error('Private API Key');
+    }
+    else if (status === 422) {
+        keys.map(function (key) {
+            console.error("".concat(key, " ").concat(errors[key]));
+        });
+    }
+    else if (status === 400) {
+        keys.map(function (key) {
+            console.error("".concat(key, " ").concat(errors[key]));
+        });
+    }
+    else {
+        console.error('Unkonwn error', status, errors);
+    }
+};
+var artaRequest = function (path, config, body, headers) { return __awaiter(void 0, void 0, void 0, function () {
+    var res, resBody, err;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, fetch("https://".concat(config.host).concat(path), {
+                    method: 'POST',
+                    body: body,
+                    headers: __assign(__assign({}, headers), { Authorization: "".concat(AUTH_KEY, " ").concat(config.apiKey), 'Content-Type': 'application/json' }),
+                })];
+            case 1:
+                res = _a.sent();
+                return [4 /*yield*/, res.json()];
+            case 2:
+                resBody = _a.sent();
+                if (!res.ok) {
+                    err = Object.assign({}, {
+                        errors: resBody['errors'],
+                        status: res.status,
+                        statusText: res.statusText,
+                    });
+                    logError(err);
+                    return [2 /*return*/, { err: err }];
+                }
+                return [2 /*return*/, resBody];
+        }
+    });
+}); };
+var loadHostedSessions = function (config, estimateBody) { return __awaiter(void 0, void 0, void 0, function () {
+    var path, body, res;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                path = '/estimate/hosted_sessions';
+                body = JSON.stringify({ hosted_session: estimateBody });
+                return [4 /*yield*/, artaRequest(path, config, body)];
+            case 1:
+                res = _a.sent();
+                return [2 /*return*/, res];
+        }
+    });
+}); };
+exports.loadHostedSessions = loadHostedSessions;
+var loadQuoteRequests = function (config, hostedSession, estimateBody) { return __awaiter(void 0, void 0, void 0, function () {
+    var path, body, headers, res;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                path = '/estimate/requests';
+                body = JSON.stringify({ request: estimateBody });
+                headers = {
+                    'hosted-session-id': hostedSession.id,
+                    'hosted-session-private-token': hostedSession.private_token,
+                };
+                return [4 /*yield*/, artaRequest(path, config, body, headers)];
+            case 1:
+                res = _a.sent();
+                res.quotes && res.quotes.forEach(function (q) { return (q.total = parseFloat(q.total)); });
+                return [2 /*return*/, res];
+        }
+    });
+}); };
+exports.loadQuoteRequests = loadQuoteRequests;
+var validateEstimateBody = function (config, estimateBody) { return __awaiter(void 0, void 0, void 0, function () {
+    var path, body, res;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                path = '/estimate/validate';
+                body = JSON.stringify({ estimate: estimateBody });
+                return [4 /*yield*/, artaRequest(path, config, body)];
+            case 1:
+                res = _a.sent();
+                return [2 /*return*/, !res.errors || res.errors.length === 0];
+        }
+    });
+}); };
+exports.validateEstimateBody = validateEstimateBody;

package/dist/typing.d.ts

@@ -0,0 +1 @@
+declare module '*.css';

package/dist/typing.js

@@ -0,0 +1 @@
+"use strict";

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@artaio/arta-browser",
+  "version": "2.0.0",
+  "description": "",
+  "source": "lib/index.ts",
+  "exports": "./dist/arta.modern.js",
+  "main": "./dist/index.js",
+  "module": "./dist/arta.module.js",
+  "unpkg": "./dist/arta.umd.js",
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "test": "npm run lint",
+    "build": "npm run build:cdn && npm run build:npm",
+    "build:npm": "./build-npm.sh && copyfiles -u 1 \"./lib/**/*.css\" \"./dist/\"",
+    "build:cdn": "microbundle -i lib/index.ts -o dist/bundle.js --external none --no-pkg-main -f umd --no-sourcemap --css inline",
+    "lint": "eslint .",
+    "lint:fix": "prettier --ignore-path .gitignore --write \"**/*.+(js|ts|tsx|jsx|json)\""
+  },
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "^5.39.0",
+    "@typescript-eslint/parser": "^5.40.1",
+    "copyfiles": "^2.4.1",
+    "eslint": "^8.24.0",
+    "eslint-config-preact": "^1.3.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-n": "^15.3.0",
+    "eslint-plugin-promise": "^6.0.1",
+    "microbundle": "^0.15.1",
+    "prettier": "2.7.1",
+    "typescript": "^4.8.4",
+    "typescript-plugin-css-modules": "^4.1.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/artaio/arta-browser.git"
+  },
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/artaio/arta-browser/issues"
+  },
+  "homepage": "https://github.com/artaio/arta-browser#readme",
+  "dependencies": {
+    "preact": "^10.11.3"
+  }
+}