@inappstory/slide-api 0.0.2 → 0.0.3

package/dist/index.cjs

@@ -1,5 +1,225 @@
 'use strict';
 
+const CONSTRUCTOR_ARGUMENTS_SYMBOL_IDENTIFIER = `___CTOR_ARGS___`;
+const CONSTRUCTOR_ARGUMENTS_SYMBOL = Symbol.for(CONSTRUCTOR_ARGUMENTS_SYMBOL_IDENTIFIER);
+
+/**
+ * A Dependency-Injection container that holds services and can produce instances of them as required.
+ * It mimics reflection by parsing the app at compile-time and supporting the generic-reflection syntax.
+ * @author Frederik Wessberg
+ */
+class DIContainer {
+    /**
+     * A map between interface names and the services that should be dependency injected
+     */
+    constructorArguments = new Map();
+    /**
+     * A Map between identifying names for services and their IRegistrationRecords.
+     */
+    serviceRegistry = new Map();
+    /**
+     * A map between identifying names for services and concrete instances of their implementation.
+     */
+    instances = new Map();
+    registerSingleton(newExpression, options) {
+        if (options == null) {
+            throw new ReferenceError(`2 arguments required, but only 0 present. ${DI_COMPILER_ERROR_HINT}`);
+        }
+        if (newExpression == null) {
+            return this.register("SINGLETON", newExpression, options);
+        }
+        else {
+            return this.register("SINGLETON", newExpression, options);
+        }
+    }
+    registerTransient(newExpression, options) {
+        if (options == null) {
+            throw new ReferenceError(`2 arguments required, but only 0 present. ${DI_COMPILER_ERROR_HINT}`);
+        }
+        if (newExpression == null) {
+            return this.register("TRANSIENT", newExpression, options);
+        }
+        else {
+            return this.register("TRANSIENT", newExpression, options);
+        }
+    }
+    /**
+     * Gets an instance of the service matching the interface given as a generic type parameter.
+     * For example, 'container.get<IFoo>()' returns a concrete instance of the implementation associated with the
+     * generic interface name.
+     *
+     * You should not pass any options to the method if using the compiler. It will do that automatically.
+     */
+    get(options) {
+        if (options == null) {
+            throw new ReferenceError(`1 argument required, but only 0 present. ${DI_COMPILER_ERROR_HINT}`);
+        }
+        return this.constructInstance(options);
+    }
+    /**
+     * Returns true if a service has been registered matching the interface given as a generic type parameter.
+     * For example, 'container.get<IFoo>()' returns a concrete instance of the implementation associated with the
+     * generic interface name.
+     *
+     * You should not pass any options to the method if using the compiler. It will do that automatically.
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    has(options) {
+        if (options == null) {
+            throw new ReferenceError(`1 argument required, but only 0 present. ${DI_COMPILER_ERROR_HINT}`);
+        }
+        return this.serviceRegistry.has(options.identifier);
+    }
+    register(kind, newExpression, options) {
+        // Take all of the constructor arguments for the implementation
+        const implementationArguments = "implementation" in options &&
+            options.implementation != null &&
+            options.implementation[CONSTRUCTOR_ARGUMENTS_SYMBOL] != null
+            ? options.implementation[CONSTRUCTOR_ARGUMENTS_SYMBOL]
+            : [];
+        this.constructorArguments.set(options.identifier, implementationArguments);
+        this.serviceRegistry.set(options.identifier, "implementation" in options && options.implementation != null
+            ? { ...options, kind }
+            : { ...options, kind, newExpression: newExpression });
+    }
+    /**
+     * Returns true if an instance exists that matches the given identifier.
+     */
+    hasInstance(identifier) {
+        return this.getInstance(identifier) != null;
+    }
+    /**
+     * Gets the cached instance, if any, associated with the given identifier.
+     */
+    getInstance(identifier) {
+        const instance = this.instances.get(identifier);
+        return instance == null ? null : instance;
+    }
+    /**
+     * Gets an IRegistrationRecord associated with the given identifier.
+     */
+    getRegistrationRecord({ identifier, parentChain, }) {
+        const record = this.serviceRegistry.get(identifier);
+        if (record == null) {
+            throw new ReferenceError(`${this.constructor.name} could not find a service for identifier: "${identifier}". ${parentChain == null || parentChain.length < 1
+                ? ""
+                : `It is required by the service: '${parentChain
+                    .map((parent) => parent.identifier)
+                    .join(" -> ")}'.`} Remember to register it as a service!`);
+        }
+        return record;
+    }
+    /**
+     * Caches the given instance so that it can be retrieved in the future.
+     */
+    setInstance(identifier, instance) {
+        this.instances.set(identifier, instance);
+        return instance;
+    }
+    /**
+     * Gets a lazy reference to another service
+     */
+    getLazyIdentifier(lazyPointer) {
+        return (new Proxy({}, { get: (_, key) => lazyPointer()[key] }));
+    }
+    /**
+     * Constructs a new instance of the given identifier and returns it.
+     * It checks the constructor arguments and injects any services it might depend on recursively.
+     */
+    constructInstance({ identifier, parentChain = [], }) {
+        const registrationRecord = this.getRegistrationRecord({
+            identifier,
+            parentChain,
+        });
+        // If an instance already exists (and it is a singleton), return that one
+        if (this.hasInstance(identifier) &&
+            registrationRecord.kind === "SINGLETON") {
+            return this.getInstance(identifier);
+        }
+        // Otherwise, instantiate a new one
+        let instance;
+        const me = {
+            identifier,
+            ref: this.getLazyIdentifier(() => instance),
+        };
+        // If a user-provided new-expression has been provided, invoke that to get an instance.
+        if ("newExpression" in registrationRecord) {
+            if (typeof registrationRecord.newExpression !== "function") {
+                throw new TypeError(`Could not instantiate the service with the identifier: '${registrationRecord.identifier}': You provided a custom instantiation argument, but it wasn't of type function. It has to be a function that returns whatever should be used as an instance of the Service!`);
+            }
+            try {
+                instance = registrationRecord.newExpression();
+            }
+            catch (ex) {
+                throw new Error(`Could not instantiate the service with the identifier: '${registrationRecord.identifier}': When you registered the service, you provided a custom instantiation function, but it threw an exception when it was run!`);
+            }
+        }
+        else {
+            // Find the arguments for the identifier
+            const mappedArgs = this.constructorArguments.get(identifier);
+            if (mappedArgs == null) {
+                throw new ReferenceError(`${this.constructor.name} could not find constructor arguments for the service: '${identifier}'. Have you registered it as a service?`);
+            }
+            // Instantiate all of the argument services (or re-use them if they were registered as singletons)
+            const instanceArgs = mappedArgs.map((dep) => {
+                if (dep === undefined)
+                    return undefined;
+                const matchedParent = parentChain.find((parent) => parent.identifier === dep);
+                if (matchedParent != null)
+                    return matchedParent.ref;
+                return this.constructInstance({
+                    identifier: dep,
+                    parentChain: [...parentChain, me],
+                });
+            });
+            try {
+                // Try to construct an instance with 'new' and if it fails, call the implementation directly.
+                const newable = registrationRecord.implementation;
+                instance = new newable(...instanceArgs);
+            }
+            catch (ex) {
+                if (registrationRecord.implementation == null) {
+                    throw new ReferenceError(`${this.constructor.name} could not construct a new service of kind: ${identifier}. Reason: No implementation was given!`);
+                }
+                const constructable = registrationRecord.implementation;
+                // Try without 'new' and call the implementation as a function.
+                instance = constructable(...instanceArgs);
+            }
+        }
+        return registrationRecord.kind === "SINGLETON"
+            ? this.setInstance(identifier, instance)
+            : instance;
+    }
+}
+const DI_COMPILER_ERROR_HINT = `Note: You must use DI-Compiler (https://github.com/wessberg/di-compiler) for this library to work correctly. Please consult the readme for instructions on how to install and configure it for your project.`;
+
+const container = new DIContainer();
+
+class WidgetsService {
+    _env;
+    _sdkApi;
+    constructor(_env, _sdkApi) {
+        this._env = _env;
+        this._sdkApi = _sdkApi;
+    }
+    get env() {
+        return this._env;
+    }
+    get sdkApi() {
+        return this._sdkApi;
+    }
+    static get [Symbol.for("___CTOR_ARGS___")]() { return [`Window`, `SDKApi`]; }
+}
+
+container.registerSingleton(undefined, { identifier: `WidgetsService`, implementation: WidgetsService });
+
+// import '../adapters/dateTimeSource/composition';
+// import '../adapters/uuidGenerator/composition';
+// import '../effects/eventHandler/composition';
+// import '../effects/logger/composition';
+// import '../effects/timer/composition';
+container.registerSingleton(() => window, { identifier: `Window` });
+
 const arPrototype = Array.prototype;
 const obPrototype = Object.prototype;
 const slice = arPrototype.slice;
@@ -813,231 +1033,103 @@ const animationApi = {
     },
 };
 
-const CONSTRUCTOR_ARGUMENTS_SYMBOL_IDENTIFIER = `___CTOR_ARGS___`;
-const CONSTRUCTOR_ARGUMENTS_SYMBOL = Symbol.for(CONSTRUCTOR_ARGUMENTS_SYMBOL_IDENTIFIER);
-
-/**
- * A Dependency-Injection container that holds services and can produce instances of them as required.
- * It mimics reflection by parsing the app at compile-time and supporting the generic-reflection syntax.
- * @author Frederik Wessberg
- */
-class DIContainer {
-    /**
-     * A map between interface names and the services that should be dependency injected
-     */
-    constructorArguments = new Map();
-    /**
-     * A Map between identifying names for services and their IRegistrationRecords.
-     */
-    serviceRegistry = new Map();
-    /**
-     * A map between identifying names for services and concrete instances of their implementation.
-     */
-    instances = new Map();
-    registerSingleton(newExpression, options) {
-        if (options == null) {
-            throw new ReferenceError(`2 arguments required, but only 0 present. ${DI_COMPILER_ERROR_HINT}`);
-        }
-        if (newExpression == null) {
-            return this.register("SINGLETON", newExpression, options);
-        }
-        else {
-            return this.register("SINGLETON", newExpression, options);
-        }
+class EsModuleSdkApi {
+    sdkBinding;
+    constructor(sdkBinding) {
+        this.sdkBinding = sdkBinding;
     }
-    registerTransient(newExpression, options) {
-        if (options == null) {
-            throw new ReferenceError(`2 arguments required, but only 0 present. ${DI_COMPILER_ERROR_HINT}`);
-        }
-        if (newExpression == null) {
-            return this.register("TRANSIENT", newExpression, options);
-        }
-        else {
-            return this.register("TRANSIENT", newExpression, options);
-        }
+    getStoryServerData(storyId) {
+        return this.sdkBinding().getStoryServerData(storyId);
     }
-    /**
-     * Gets an instance of the service matching the interface given as a generic type parameter.
-     * For example, 'container.get<IFoo>()' returns a concrete instance of the implementation associated with the
-     * generic interface name.
-     *
-     * You should not pass any options to the method if using the compiler. It will do that automatically.
-     */
-    get(options) {
-        if (options == null) {
-            throw new ReferenceError(`1 argument required, but only 0 present. ${DI_COMPILER_ERROR_HINT}`);
-        }
-        return this.constructInstance(options);
+    getSlideDuration(storyId, slideIndex) {
+        return this.sdkBinding().getSlideDuration(storyId, slideIndex);
     }
-    /**
-     * Returns true if a service has been registered matching the interface given as a generic type parameter.
-     * For example, 'container.get<IFoo>()' returns a concrete instance of the implementation associated with the
-     * generic interface name.
-     *
-     * You should not pass any options to the method if using the compiler. It will do that automatically.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    has(options) {
-        if (options == null) {
-            throw new ReferenceError(`1 argument required, but only 0 present. ${DI_COMPILER_ERROR_HINT}`);
-        }
-        return this.serviceRegistry.has(options.identifier);
+    showNextSlide(duration) {
+        this.sdkBinding().showNextSlide(duration);
     }
-    register(kind, newExpression, options) {
-        // Take all of the constructor arguments for the implementation
-        const implementationArguments = "implementation" in options &&
-            options.implementation != null &&
-            options.implementation[CONSTRUCTOR_ARGUMENTS_SYMBOL] != null
-            ? options.implementation[CONSTRUCTOR_ARGUMENTS_SYMBOL]
-            : [];
-        this.constructorArguments.set(options.identifier, implementationArguments);
-        this.serviceRegistry.set(options.identifier, "implementation" in options && options.implementation != null
-            ? { ...options, kind }
-            : { ...options, kind, newExpression: newExpression });
+    sendStatisticEvent(name, data, devPayload) {
+        this.sdkBinding().sendStatisticEvent(name, data, devPayload);
     }
-    /**
-     * Returns true if an instance exists that matches the given identifier.
-     */
-    hasInstance(identifier) {
-        return this.getInstance(identifier) != null;
+    getStoryLocalData() {
+        return this.sdkBinding().getStoryLocalData();
     }
-    /**
-     * Gets the cached instance, if any, associated with the given identifier.
-     */
-    getInstance(identifier) {
-        const instance = this.instances.get(identifier);
-        return instance == null ? null : instance;
+    isExistsShowLayer() {
+        return true;
     }
-    /**
-     * Gets an IRegistrationRecord associated with the given identifier.
-     */
-    getRegistrationRecord({ identifier, parentChain, }) {
-        const record = this.serviceRegistry.get(identifier);
-        if (record == null) {
-            throw new ReferenceError(`${this.constructor.name} could not find a service for identifier: "${identifier}". ${parentChain == null || parentChain.length < 1
-                ? ""
-                : `It is required by the service: '${parentChain
-                    .map((parent) => parent.identifier)
-                    .join(" -> ")}'.`} Remember to register it as a service!`);
-        }
-        return record;
+    showLayer(index) {
+        this.sdkBinding().showLayer(index);
     }
-    /**
-     * Caches the given instance so that it can be retrieved in the future.
-     */
-    setInstance(identifier, instance) {
-        this.instances.set(identifier, instance);
-        return instance;
+    get storyAnimation() {
+        return animationApi;
     }
-    /**
-     * Gets a lazy reference to another service
-     */
-    getLazyIdentifier(lazyPointer) {
-        return (new Proxy({}, { get: (_, key) => lazyPointer()[key] }));
+    get isAndroid() {
+        return false;
     }
-    /**
-     * Constructs a new instance of the given identifier and returns it.
-     * It checks the constructor arguments and injects any services it might depend on recursively.
-     */
-    constructInstance({ identifier, parentChain = [], }) {
-        const registrationRecord = this.getRegistrationRecord({
-            identifier,
-            parentChain,
-        });
-        // If an instance already exists (and it is a singleton), return that one
-        if (this.hasInstance(identifier) &&
-            registrationRecord.kind === "SINGLETON") {
-            return this.getInstance(identifier);
-        }
-        // Otherwise, instantiate a new one
-        let instance;
-        const me = {
-            identifier,
-            ref: this.getLazyIdentifier(() => instance),
-        };
-        // If a user-provided new-expression has been provided, invoke that to get an instance.
-        if ("newExpression" in registrationRecord) {
-            if (typeof registrationRecord.newExpression !== "function") {
-                throw new TypeError(`Could not instantiate the service with the identifier: '${registrationRecord.identifier}': You provided a custom instantiation argument, but it wasn't of type function. It has to be a function that returns whatever should be used as an instance of the Service!`);
-            }
-            try {
-                instance = registrationRecord.newExpression();
-            }
-            catch (ex) {
-                throw new Error(`Could not instantiate the service with the identifier: '${registrationRecord.identifier}': When you registered the service, you provided a custom instantiation function, but it threw an exception when it was run!`);
-            }
-        }
-        else {
-            // Find the arguments for the identifier
-            const mappedArgs = this.constructorArguments.get(identifier);
-            if (mappedArgs == null) {
-                throw new ReferenceError(`${this.constructor.name} could not find constructor arguments for the service: '${identifier}'. Have you registered it as a service?`);
-            }
-            // Instantiate all of the argument services (or re-use them if they were registered as singletons)
-            const instanceArgs = mappedArgs.map((dep) => {
-                if (dep === undefined)
-                    return undefined;
-                const matchedParent = parentChain.find((parent) => parent.identifier === dep);
-                if (matchedParent != null)
-                    return matchedParent.ref;
-                return this.constructInstance({
-                    identifier: dep,
-                    parentChain: [...parentChain, me],
-                });
-            });
-            try {
-                // Try to construct an instance with 'new' and if it fails, call the implementation directly.
-                const newable = registrationRecord.implementation;
-                instance = new newable(...instanceArgs);
-            }
-            catch (ex) {
-                if (registrationRecord.implementation == null) {
-                    throw new ReferenceError(`${this.constructor.name} could not construct a new service of kind: ${identifier}. Reason: No implementation was given!`);
-                }
-                const constructable = registrationRecord.implementation;
-                // Try without 'new' and call the implementation as a function.
-                instance = constructable(...instanceArgs);
-            }
-        }
-        return registrationRecord.kind === "SINGLETON"
-            ? this.setInstance(identifier, instance)
-            : instance;
+    get isIOS() {
+        return false;
     }
-}
-const DI_COMPILER_ERROR_HINT = `Note: You must use DI-Compiler (https://github.com/wessberg/di-compiler) for this library to work correctly. Please consult the readme for instructions on how to install and configure it for your project.`;
-
-const container = new DIContainer();
-
-class WidgetsService {
-    _env;
-    _sdkApi;
-    constructor(_env, _sdkApi) {
-        this._env = _env;
-        this._sdkApi = _sdkApi;
+    get isWeb() {
+        return true;
     }
-    get env() {
-        return this._env;
+    pauseUI() {
+        this.sdkBinding().pauseUI();
     }
-    get sdkApi() {
-        return this._sdkApi;
+    resumeUI() {
+        this.sdkBinding().resumeUI();
     }
-    static get [Symbol.for("___CTOR_ARGS___")]() { return [`Window`, `SDKApi`]; }
+    get isExistsShowStoryTextInput() {
+        return true;
+    }
+    showStoryTextInput(id, data) {
+        this.sdkBinding().showStoryTextInput(id, data);
+    }
+    setStoryLocalData(keyValue, sendToServer) {
+        this.sdkBinding().setStoryLocalData(keyValue, sendToServer);
+    }
+    getWidgetsSharedData(storyId, widget) {
+        return this.sdkBinding().getWidgetsSharedData(storyId, widget);
+    }
+    vibrate(pattern) {
+        navigator.vibrate(pattern);
+    }
+    openUrl(target) {
+        this.sdkBinding().openUrl(target);
+    }
+    sendApiRequest(url, method, params, headers, data, profilingKey) {
+        return this.sdkBinding().sendApiRequest(url, method, params, headers, data, profilingKey);
+    }
+    sendApiRequestSupported() {
+        return true;
+    }
+    showToast(text) { }
+    get sdkCanSendShareComplete() {
+        return true;
+    }
+    get isExistsShare() {
+        return true;
+    }
+    share(id, config) {
+        this.sdkBinding().share(id, config);
+    }
+    shareSlideScreenshot(shareId, hideElementsSelector) {
+        this.sdkBinding().shareSlideScreenshot(shareId, hideElementsSelector);
+    }
+    get isExistsShowStorySlide() {
+        return true;
+    }
+    showStorySlide(index) {
+        this.sdkBinding().showStorySlide(index);
+    }
+    get isExistsShowNextStory() {
+        return true;
+    }
+    storyShowNext() {
+        this.sdkBinding().storyShowNext();
+    }
+    static get [Symbol.for("___CTOR_ARGS___")]() { return [`() => SDKInterface`]; }
 }
 
-container.registerSingleton(undefined, { identifier: `WidgetsService`, implementation: WidgetsService });
-
-// import '../adapters/dateTimeSource/composition';
-// import '../adapters/uuidGenerator/composition';
-// import '../effects/eventHandler/composition';
-// import '../effects/logger/composition';
-// import '../effects/timer/composition';
-container.registerSingleton(() => window, { identifier: `Window` });
-
 class WidgetBase {
-    /**
-     * @see https://github.com/Microsoft/TypeScript/issues/3841#issuecomment-337560146
-     */
-    ["constructor"];
     static DEFAULTS = {
         slide: null,
         activateAfterCreate: false,
@@ -3044,14 +3136,14 @@ class WidgetQuiz extends WidgetBase {
         if (this.localData) {
             if (this.localData["_q_g_" + this.elementId + "_sa"] !== undefined) {
                 this._selectAnswer(this.localData["_q_g_" + this.elementId + "_sa"]);
-                this.constructor.setLocalData(this.localData, false);
+                this.setLocalData(this.localData, false);
             }
             else {
                 this._clearAnswerSelection();
             }
             if (this.localData["_q_fo_at"] === undefined) {
                 this.localData["_q_fo_at"] = Math.round(new Date().getTime() / 1000);
-                this.constructor.setLocalData(this.localData, false);
+                this.setLocalData(this.localData, false);
             }
         }
         this.firstOpenTime = new Date().getTime();
@@ -4888,7 +4980,9 @@ class WidgetVote extends WidgetBase {
     static get [Symbol.for("___CTOR_ARGS___")]() { return [`HTMLElement`, `Partial`]; }
 }
 
+let sdkInterface;
 const getSlideApi = (_sdkInterface) => {
+    sdkInterface = _sdkInterface;
     return {
         Animation: animationApi,
         WidgetCopy: WidgetCopy.api,
@@ -4908,4 +5002,6 @@ const getSlideApi = (_sdkInterface) => {
     };
 };
 
+container.registerSingleton(() => new EsModuleSdkApi(() => sdkInterface), { identifier: `SDKApi` });
+
 exports.getSlideApi = getSlideApi;