@tiendanube/nexo 0.1.7 → 0.2.0

package/actions/actions.d.ts

@@ -0,0 +1,52 @@
+export declare const ACTION_READY = "app/ready";
+export declare const ACTION_CONNECTED = "app/connected";
+export declare const ACTION_NAVIGATE_EXIT = "app/navigate/exit";
+export declare const ACTION_NAVIGATE_BACK = "app/navigate/back";
+export declare const ACTION_NAVIGATE_GOTO = "app/navigate/goTo";
+export type NavigateGoToRequest = {
+    pathname: string;
+};
+export declare const ACTION_NAVIGATE_PATHNAME = "app/navigate/pathname";
+export type NavigatePathnameResponse = {
+    pathname: string | null;
+};
+export declare const ACTION_NAVIGATE_SYNC = "app/navigate/sync";
+export type NavigateSyncResponse = {
+    path: string;
+    replace?: boolean;
+};
+export declare const ACTION_AUTH_SESSION_TOKEN = "app/auth/sessionToken";
+export type AuthSessionTokenResponse = {
+    token: string;
+};
+export declare const ACTION_DEVICE = "app/device";
+export type DeviceResponse = {
+    isMobile: boolean;
+};
+export declare const ACTION_STORE_INFO = "app/store/info";
+export type StoreInfoResponse = {
+    id: string;
+    name: string;
+    url: string;
+    country: string;
+    language: string;
+    currency: string;
+};
+export declare const ACTION_UTILS_COPY_TO_CLIPBOARD = "app/utils/copyToClipboard";
+export type CopyToClipboardRequest = {
+    text: string;
+};
+export type CopyToClipboardResponse = {
+    success: boolean;
+};
+export declare const ACTION_NAVIGATE_GOTO_OLD_ADMIN = "app/navigate/goToOldAdmin";
+export type NavigateGoToOldAdminRequest = {
+    pathToOldAdmin: string;
+};
+export declare const ACTION_NAVIGATE_HEADER = "app/navigate/header";
+export type NavigateHeaderRequest = {
+    goTo?: 'back' | string;
+    goToAdmin?: string;
+    text?: string;
+    remove?: boolean;
+};

package/actions/actions.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTION_NAVIGATE_HEADER = exports.ACTION_NAVIGATE_GOTO_OLD_ADMIN = exports.ACTION_UTILS_COPY_TO_CLIPBOARD = exports.ACTION_STORE_INFO = exports.ACTION_DEVICE = exports.ACTION_AUTH_SESSION_TOKEN = exports.ACTION_NAVIGATE_SYNC = exports.ACTION_NAVIGATE_PATHNAME = exports.ACTION_NAVIGATE_GOTO = exports.ACTION_NAVIGATE_BACK = exports.ACTION_NAVIGATE_EXIT = exports.ACTION_CONNECTED = exports.ACTION_READY = void 0;
+exports.ACTION_READY = 'app/ready';
+exports.ACTION_CONNECTED = 'app/connected';
+exports.ACTION_NAVIGATE_EXIT = 'app/navigate/exit';
+exports.ACTION_NAVIGATE_BACK = 'app/navigate/back';
+exports.ACTION_NAVIGATE_GOTO = 'app/navigate/goTo';
+exports.ACTION_NAVIGATE_PATHNAME = 'app/navigate/pathname';
+exports.ACTION_NAVIGATE_SYNC = 'app/navigate/sync';
+exports.ACTION_AUTH_SESSION_TOKEN = 'app/auth/sessionToken';
+exports.ACTION_DEVICE = 'app/device';
+exports.ACTION_STORE_INFO = 'app/store/info';
+exports.ACTION_UTILS_COPY_TO_CLIPBOARD = 'app/utils/copyToClipboard';
+exports.ACTION_NAVIGATE_GOTO_OLD_ADMIN = 'app/navigate/goToOldAdmin';
+exports.ACTION_NAVIGATE_HEADER = 'app/navigate/header';

package/actions/index.d.ts

@@ -0,0 +1 @@
+export * from './actions';

package/actions/index.js

@@ -0,0 +1,17 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./actions"), exports);

package/core/nexoClient.d.ts

@@ -0,0 +1,13 @@
+import { Dispatch, Suscribe } from './transporter';
+type OnReady = (callback: () => void) => void;
+export interface NexoClient {
+    clientId: string;
+    dispatch: Dispatch;
+    suscribe: Suscribe;
+    onReady: OnReady;
+}
+export declare const create: ({ clientId, log, }: {
+    clientId: string;
+    log?: boolean | undefined;
+}) => NexoClient;
+export {};

package/core/nexoClient.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create = void 0;
+var actions_1 = require("../actions/actions");
+var transporter_1 = require("./transporter");
+var create = function (_a) {
+    var clientId = _a.clientId, _b = _a.log, log = _b === void 0 ? false : _b;
+    var isReadyMutable = false;
+    var _c = (0, transporter_1.registerIframe)(log), dispatch = _c.dispatch, suscribe = _c.suscribe;
+    var onReady = function (callback) {
+        if (isReadyMutable) {
+            throw new Error('onReady should be run only once');
+        }
+        var readyUnsuscribe = suscribe(actions_1.ACTION_CONNECTED, function () {
+            callback();
+            readyUnsuscribe();
+            isReadyMutable = true;
+        });
+        dispatch({ type: actions_1.ACTION_CONNECTED });
+    };
+    return {
+        clientId: clientId,
+        dispatch: dispatch,
+        suscribe: suscribe,
+        onReady: onReady,
+    };
+};
+exports.create = create;

package/core/transporter.d.ts

@@ -0,0 +1,21 @@
+export type Dispatch = (event: Message) => void;
+type Unsuscribe = () => void;
+export type Suscribe = (type: string, callback: any) => Unsuscribe;
+export type OnReady = () => void;
+export interface Message<T = unknown> {
+    type: string;
+    payload?: T;
+}
+export interface MessageToSend extends Message {
+    source: {
+        host: string;
+    };
+}
+export type Handler = (message: Message) => void;
+export declare const createHandler: (type: string, callback: (payload: unknown) => void) => Handler;
+export declare const suscribeAndUnsuscribeHandlers: (handlers: Handler[], handler: Handler) => () => void;
+export declare const registerIframe: (log?: boolean) => {
+    dispatch: Dispatch;
+    suscribe: Suscribe;
+};
+export {};

package/core/transporter.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerIframe = exports.suscribeAndUnsuscribeHandlers = exports.createHandler = void 0;
+var dispatchMessage = function (message) {
+    if (window.parent === window) {
+        return;
+    }
+    if (!('postMessage' in window.parent)) {
+        console.error('can not send a event', message);
+    }
+    logger('dispatched', message.type, message.payload);
+    window.parent.postMessage(message, '*');
+};
+var createHandler = function (type, callback) {
+    return function (message) {
+        if (message.type === type) {
+            logger('received', message.type, message.payload);
+            callback(message.payload);
+        }
+    };
+};
+exports.createHandler = createHandler;
+var logger = function (from, type, payload) {
+    if (isLogged) {
+        var color = from === 'dispatched' ? '#f5ec7f' : '#00cc35';
+        console.group('%c ' + from, 'color: ' + color);
+        console.log('👉 ', type);
+        var stringPayload = JSON.stringify(payload);
+        stringPayload && console.log('📦  ' + stringPayload);
+        console.groupEnd();
+    }
+};
+var suscribeAndUnsuscribeHandlers = function (handlers, handler) {
+    handlers.push(handler);
+    return function () {
+        handlers.splice(handlers.indexOf(handler), 1);
+    };
+};
+exports.suscribeAndUnsuscribeHandlers = suscribeAndUnsuscribeHandlers;
+var isLogged = false;
+var registerIframe = function (log) {
+    if (log === void 0) { log = false; }
+    isLogged = log;
+    var handlers = [];
+    window.addEventListener('message', function (event) {
+        handlers.forEach(function (handler) { return handler(event.data); });
+    });
+    return {
+        dispatch: dispatchMessage,
+        suscribe: function (type, callback) {
+            var handler = (0, exports.createHandler)(type, callback);
+            return (0, exports.suscribeAndUnsuscribeHandlers)(handlers, handler);
+        },
+    };
+};
+exports.registerIframe = registerIframe;

package/core/utils.d.ts

@@ -0,0 +1,4 @@
+import { NexoClient } from './nexoClient';
+import { Message } from './transporter';
+export declare const message: <TPayload = unknown>(type: string, payload?: TPayload | undefined) => Message;
+export declare const asyncAction: <TResponse, TRequest = undefined>(nexo: NexoClient, action: string, payload?: TRequest | undefined) => Promise<TResponse>;

package/core/utils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asyncAction = exports.message = void 0;
+var message = function (type, payload) { return ({
+    type: type,
+    payload: payload,
+}); };
+exports.message = message;
+var asyncAction = function (nexo, action, payload) {
+    return new Promise(function (resolve) {
+        var unsuscribe = nexo.suscribe(action, function (response) {
+            resolve(response);
+            unsuscribe();
+        });
+        nexo.dispatch((0, exports.message)(action, payload));
+    });
+};
+exports.asyncAction = asyncAction;

package/helpers/helpers.d.ts

@@ -0,0 +1,16 @@
+import { StoreInfoResponse, NavigateHeaderRequest } from '../actions/actions';
+import { NexoClient } from '../core/nexoClient';
+export declare const connect: (nexo: NexoClient, ttl?: number) => Promise<void>;
+export declare const iAmReady: (nexo: NexoClient) => void;
+export declare const navigateExit: (nexo: NexoClient) => void;
+export declare const navigateBack: (nexo: NexoClient) => void;
+export declare const getSessionToken: (nexo: NexoClient) => Promise<string>;
+export declare const getCurrentPathname: (nexo: NexoClient) => Promise<string | null>;
+export declare const syncPathname: (nexo: NexoClient, pathname: string) => void;
+export declare const getStoreInfo: (nexo: NexoClient) => Promise<StoreInfoResponse>;
+export declare const getIsMobileDevice: (nexo: NexoClient) => Promise<boolean>;
+export declare const goTo: (nexo: NexoClient, pathname: string) => void;
+export declare const goToOldAdmin: (nexo: NexoClient, pathToOldAdmin: string) => void;
+export declare const copyToClipboard: (nexo: NexoClient, text: string) => Promise<boolean>;
+export declare const navigateHeader: (nexo: NexoClient, config: NavigateHeaderRequest) => void;
+export declare const navigateHeaderRemove: (nexo: NexoClient) => void;

package/helpers/helpers.js

@@ -0,0 +1,149 @@
+"use strict";
+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.navigateHeaderRemove = exports.navigateHeader = exports.copyToClipboard = exports.goToOldAdmin = exports.goTo = exports.getIsMobileDevice = exports.getStoreInfo = exports.syncPathname = exports.getCurrentPathname = exports.getSessionToken = exports.navigateBack = exports.navigateExit = exports.iAmReady = exports.connect = void 0;
+var actions_1 = require("../actions/actions");
+var utils_1 = require("../core/utils");
+var connect = function (nexo, ttl) {
+    if (ttl === void 0) { ttl = 3000; }
+    return new Promise(function (resolve, reject) {
+        var timeOut = setTimeout(function () {
+            reject(new Error('Timeout'));
+        }, ttl);
+        nexo.onReady(function () {
+            resolve();
+            clearTimeout(timeOut);
+        });
+    });
+};
+exports.connect = connect;
+var iAmReady = function (nexo) {
+    nexo.dispatch((0, utils_1.message)(actions_1.ACTION_READY));
+};
+exports.iAmReady = iAmReady;
+var navigateExit = function (nexo) {
+    nexo.dispatch((0, utils_1.message)(actions_1.ACTION_NAVIGATE_EXIT));
+};
+exports.navigateExit = navigateExit;
+var navigateBack = function (nexo) {
+    nexo.dispatch((0, utils_1.message)(actions_1.ACTION_NAVIGATE_BACK));
+};
+exports.navigateBack = navigateBack;
+var getSessionToken = function (nexo) { return __awaiter(void 0, void 0, void 0, function () {
+    var token;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, utils_1.asyncAction)(nexo, actions_1.ACTION_AUTH_SESSION_TOKEN)];
+            case 1:
+                token = (_a.sent()).token;
+                return [2 /*return*/, token];
+        }
+    });
+}); };
+exports.getSessionToken = getSessionToken;
+var getCurrentPathname = function (nexo) { return __awaiter(void 0, void 0, void 0, function () {
+    var pathname;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, utils_1.asyncAction)(nexo, actions_1.ACTION_NAVIGATE_PATHNAME)];
+            case 1:
+                pathname = (_a.sent()).pathname;
+                return [2 /*return*/, pathname];
+        }
+    });
+}); };
+exports.getCurrentPathname = getCurrentPathname;
+var syncPathname = function (nexo, pathname) {
+    nexo.dispatch((0, utils_1.message)(actions_1.ACTION_NAVIGATE_SYNC, { pathname: pathname }));
+};
+exports.syncPathname = syncPathname;
+var getStoreInfo = function (nexo) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, utils_1.asyncAction)(nexo, actions_1.ACTION_STORE_INFO)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+exports.getStoreInfo = getStoreInfo;
+var getIsMobileDevice = function (nexo) { return __awaiter(void 0, void 0, void 0, function () {
+    var device;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, utils_1.asyncAction)(nexo, actions_1.ACTION_DEVICE)];
+            case 1:
+                device = _a.sent();
+                return [2 /*return*/, device.isMobile];
+        }
+    });
+}); };
+exports.getIsMobileDevice = getIsMobileDevice;
+var goTo = function (nexo, pathname) {
+    nexo.dispatch((0, utils_1.message)(actions_1.ACTION_NAVIGATE_GOTO, { pathname: pathname }));
+};
+exports.goTo = goTo;
+var goToOldAdmin = function (nexo, pathToOldAdmin) {
+    nexo.dispatch((0, utils_1.message)(actions_1.ACTION_NAVIGATE_GOTO_OLD_ADMIN, { pathToOldAdmin: pathToOldAdmin }));
+};
+exports.goToOldAdmin = goToOldAdmin;
+var copyToClipboard = function (nexo, text) { return __awaiter(void 0, void 0, void 0, function () {
+    var success;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, utils_1.asyncAction)(nexo, actions_1.ACTION_UTILS_COPY_TO_CLIPBOARD, { text: text })];
+            case 1:
+                success = (_a.sent()).success;
+                return [2 /*return*/, success];
+        }
+    });
+}); };
+exports.copyToClipboard = copyToClipboard;
+var navigateHeader = function (nexo, config) {
+    nexo.dispatch({
+        type: actions_1.ACTION_NAVIGATE_HEADER,
+        payload: config,
+    });
+};
+exports.navigateHeader = navigateHeader;
+var navigateHeaderRemove = function (nexo) {
+    nexo.dispatch({
+        type: actions_1.ACTION_NAVIGATE_HEADER,
+        payload: { remove: true },
+    });
+};
+exports.navigateHeaderRemove = navigateHeaderRemove;

package/helpers/index.d.ts

@@ -0,0 +1 @@
+export * from './helpers';

package/helpers/index.js

@@ -0,0 +1,17 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./helpers"), exports);

package/index.d.ts

@@ -0,0 +1,8 @@
+export { NexoClient } from './core/nexoClient';
+declare const nexo: {
+    create: ({ clientId, log, }: {
+        clientId: string;
+        log?: boolean | undefined;
+    }) => import("./core/nexoClient").NexoClient;
+};
+export default nexo;

package/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var nexoClient_1 = require("./core/nexoClient");
+var nexo = {
+    create: nexoClient_1.create,
+};
+exports.default = nexo;

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@tiendanube/nexo",
-  "version": "0.1.7",
+  "version": "0.2.0",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",
   "scripts": {
     "build": "tsc",
+    "publish:release": "yarn version apply && yarn build && yarn npm publish --tolerate-republish --access public",
     "test": "echo \"Error: no test specified\" && exit 1",
     "lint": "eslint .",
     "lint:fix": "eslint --fix",
@@ -29,6 +30,11 @@
     "eslint-plugin-prettier": "4.2.1",
     "eslint-plugin-react": "7.31.1",
     "prettier": "2.7.1",
-    "typescript": "4.8.2"
-  }
-}
+    "typescript": "4.9.5"
+  },
+  "engines": {
+    "node": ">=16.x <=18.x",
+    "yarn": ">=3.4.1"
+  },
+  "packageManager": "yarn@3.4.1"
+}