@contentful/app-sdk 5.0.0-alpha.1 → 5.0.0-alpha.2

package/README.md

@@ -16,7 +16,7 @@ for the Contentful Web App. Every Contentful App has to include the library in i
 - [Forma 36: The Contentful Design System](https://f36.contentful.com/)
 - [Forma 36 guide for Contentful Apps](https://www.contentful.com/developers/docs/extensibility/ui-extensions/component-library/)
 - [`create-contentful-app`](https://github.com/contentful/create-contentful-app) - CLI tool for developing apps without the hassle of managing build configurations
-- [`contentful-ui-extensions-sdk` at npm](https://www.npmjs.com/package/contentful-ui-extensions-sdk)
+- [`@contentful/app-sdk` at npm](https://www.npmjs.com/package/@contentful/app-sdk)
 
 ## Getting help
 
@@ -31,8 +31,6 @@ information needs to be discussed, then the conversation should be handled via o
 
 A new package version is automatically published to npm using [semantic-release](https://github.com/semantic-release/semantic-release).
 
-To manually publish the package, run `npm run publish-all`.
-
 This repository is published as `@contentful/app-sdk` package.
 
 #### Canary releases
@@ -71,10 +69,6 @@ All the typings are in the [`types`](./lib/types) folder and they map 1-to-1 API
 The [`entities`](./lib/types/entities.ts) file maps Contentful entities in TypeScript.
 [`utils`](./lib/types/utils.ts) includes utility types, meant to save on characters to type.
 
-#### `scripts`
-
-Includes utility tools for maintainers.
-
 #### `test`
 
 Includes unit tests (run by [mocha](https://mochajs.org/))

package/dist/api.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const field_1 = require("./field");
+const field_locale_1 = require("./field-locale");
+const window_1 = require("./window");
+const entry_1 = require("./entry");
+const dialogs_1 = require("./dialogs");
+const editor_1 = require("./editor");
+const navigator_1 = require("./navigator");
+const app_1 = require("./app");
+const locations_1 = require("./locations");
+const cmaAdapter_1 = require("./cmaAdapter");
+const cma_1 = require("./cma");
+const DEFAULT_API_PRODUCERS = [
+    makeSharedAPI,
+    makeEntryAPI,
+    makeFieldAPI,
+    makeEditorAPI,
+    makeWindowAPI,
+];
+const LOCATION_TO_API_PRODUCERS = {
+    [locations_1.default.LOCATION_ENTRY_FIELD]: DEFAULT_API_PRODUCERS,
+    [locations_1.default.LOCATION_ENTRY_FIELD_SIDEBAR]: DEFAULT_API_PRODUCERS,
+    [locations_1.default.LOCATION_ENTRY_SIDEBAR]: [makeSharedAPI, makeEntryAPI, makeEditorAPI, makeWindowAPI],
+    [locations_1.default.LOCATION_ENTRY_EDITOR]: [makeSharedAPI, makeEntryAPI, makeEditorAPI],
+    [locations_1.default.LOCATION_DIALOG]: [makeSharedAPI, makeDialogAPI, makeWindowAPI],
+    [locations_1.default.LOCATION_PAGE]: [makeSharedAPI],
+    [locations_1.default.LOCATION_HOME]: [makeSharedAPI],
+    [locations_1.default.LOCATION_APP_CONFIG]: [makeSharedAPI, makeAppAPI],
+};
+function createAPI(channel, data, currentGlobal) {
+    const producers = LOCATION_TO_API_PRODUCERS[data.location] || DEFAULT_API_PRODUCERS;
+    return producers.reduce((api, produce) => {
+        return { ...api, ...produce(channel, data, currentGlobal) };
+    }, {});
+}
+exports.default = createAPI;
+function makeSharedAPI(channel, data) {
+    const { user, parameters, locales, ids } = data;
+    const currentLocation = data.location || locations_1.default.LOCATION_ENTRY_FIELD;
+    return {
+        cma: (0, cma_1.createCMAClient)(ids, channel),
+        cmaAdapter: (0, cmaAdapter_1.createAdapter)(channel),
+        location: {
+            current: currentLocation,
+            is: (tested) => currentLocation === tested,
+        },
+        user,
+        parameters,
+        locales: {
+            available: locales.available,
+            default: locales.default,
+            names: locales.names,
+            fallbacks: locales.fallbacks,
+            optional: locales.optional,
+            direction: locales.direction,
+        },
+        dialogs: (0, dialogs_1.default)(channel, ids),
+        // Typecast because promises returned by navigator methods aren't typed
+        navigator: (0, navigator_1.default)(channel, ids),
+        notifier: {
+            success: (message) => channel.send('notify', { type: 'success', message }),
+            error: (message) => channel.send('notify', { type: 'error', message }),
+            warning: (message) => channel.send('notify', { type: 'warning', message }),
+        },
+        ids,
+        access: {
+            can: (action, entity, patch) => channel.call('checkAccess', action, entity, patch),
+            canEditAppConfig: () => channel.call('checkAppConfigAccess'),
+        },
+    };
+}
+function makeWindowAPI(channel, _data, currentGlobal) {
+    return {
+        window: (0, window_1.default)(currentGlobal, channel),
+    };
+}
+function makeEditorAPI(channel, data) {
+    const { editorInterface, editor } = data;
+    return {
+        editor: (0, editor_1.default)(channel, editorInterface, editor),
+    };
+}
+function makeEntryAPI(channel, { locales, contentType, entry, fieldInfo }) {
+    const createEntryField = (info) => new field_1.default(channel, info, locales.default);
+    return {
+        contentType,
+        entry: (0, entry_1.default)(channel, entry, fieldInfo, createEntryField),
+    };
+}
+function makeFieldAPI(channel, { field }) {
+    if (!field) {
+        throw new Error('FieldAPI called for location without "field" property defined.');
+    }
+    return {
+        field: new field_locale_1.default(channel, field),
+    };
+}
+function makeDialogAPI(channel) {
+    return {
+        close: (data) => channel.send('closeDialog', data),
+    };
+}
+function makeAppAPI(channel) {
+    const app = (0, app_1.default)(channel);
+    return {
+        app,
+    };
+}

package/dist/app.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const HOOK_STAGE_PRE_INSTALL = 'preInstall';
+const HOOK_STAGE_POST_INSTALL = 'postInstall';
+const isObject = (o) => typeof o === 'object' && o !== null && !Array.isArray(o);
+const isFunction = (f) => typeof f === 'function';
+const isPromise = (p) => isObject(p) && isFunction(p.then);
+const handleHandlerError = (err) => {
+    console.error(err);
+    return Promise.resolve(false);
+};
+const runHandler = (handler, defaultResult, handlerArg) => {
+    // Handler was not registered. Registering a handler is not
+    // required. We resolve with the default provided in this case.
+    if (!isFunction(handler)) {
+        return Promise.resolve(defaultResult);
+    }
+    // If handler is synchronous it can throw and we need to
+    // catch it. We resolve with `false` in this case.
+    let maybeResultPromise;
+    try {
+        maybeResultPromise = typeof handlerArg === 'undefined' ? handler() : handler(handlerArg);
+    }
+    catch (err) {
+        return handleHandlerError(err);
+    }
+    // If handler is synchronous, we wrap the result with a promise
+    // and deal only with Promises API below.
+    let resultPromise = maybeResultPromise;
+    if (!isPromise(resultPromise)) {
+        resultPromise = Promise.resolve(resultPromise);
+    }
+    return resultPromise
+        .then((result) => {
+        if (result instanceof Error) {
+            return Promise.reject(result);
+        }
+        else if (result === false) {
+            return false;
+        }
+        else if (!isObject(result)) {
+            return defaultResult;
+        }
+        else {
+            return result;
+        }
+    }, handleHandlerError)
+        .catch(handleHandlerError);
+};
+function createApp(channel) {
+    const handlers = {
+        [HOOK_STAGE_PRE_INSTALL]: null,
+        [HOOK_STAGE_POST_INSTALL]: null,
+    };
+    const setHandler = (stage, handler) => {
+        if (!isFunction(handler)) {
+            throw new Error('Handler must be a function.');
+        }
+        else {
+            handlers[stage] = handler;
+        }
+    };
+    channel.addHandler('appHook', ({ stage, installationRequestId, err, }) => {
+        if (stage === HOOK_STAGE_PRE_INSTALL) {
+            return runHandler(handlers[stage], {}).then((result) => {
+                return channel.send('appHookResult', { stage, installationRequestId, result });
+            });
+        }
+        else if (stage === HOOK_STAGE_POST_INSTALL) {
+            return runHandler(handlers[stage], undefined, err || null).then(() => {
+                return channel.send('appHookResult', { stage, installationRequestId });
+            });
+        }
+        else {
+            return Promise.resolve();
+        }
+    });
+    return {
+        setReady() {
+            return channel.call('callAppMethod', 'setReady');
+        },
+        isInstalled() {
+            return channel.call('callAppMethod', 'isInstalled');
+        },
+        getParameters() {
+            return channel.call('callAppMethod', 'getParameters');
+        },
+        getCurrentState() {
+            return channel.call('callAppMethod', 'getCurrentState');
+        },
+        onConfigure(handler) {
+            setHandler(HOOK_STAGE_PRE_INSTALL, handler);
+        },
+        onConfigurationCompleted(handler) {
+            setHandler(HOOK_STAGE_POST_INSTALL, handler);
+        },
+    };
+}
+exports.default = createApp;

package/dist/channel.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendInitMessage = exports.Channel = exports.connect = void 0;
+const signal_1 = require("./signal");
+function connect(currentGlobal, onConnect) {
+    waitForConnect(currentGlobal, (params, messageQueue) => {
+        const channel = new Channel(params.id, currentGlobal);
+        onConnect(channel, params, messageQueue);
+    });
+}
+exports.connect = connect;
+function waitForConnect(currentGlobal, onConnect) {
+    currentGlobal.addEventListener('message', listener);
+    function listener(event) {
+        const message = event.data;
+        if (message.method === 'connect') {
+            currentGlobal.removeEventListener('message', listener);
+            onConnect(...message.params);
+        }
+    }
+}
+class Channel {
+    constructor(sourceId, currentGlobal) {
+        this._messageHandlers = {};
+        this._responseHandlers = {};
+        this._send = createSender(sourceId, currentGlobal.parent);
+        currentGlobal.addEventListener('message', (event) => {
+            this._handleMessage(event.data);
+        });
+    }
+    // call method with name `method` exposed by contentful web app `window`
+    call(method, ...params) {
+        const messageId = this._send(method, params);
+        return new Promise((resolve, reject) => {
+            this._responseHandlers[messageId] = { resolve, reject };
+        });
+    }
+    send(method, ...params) {
+        this._send(method, params);
+    }
+    addHandler(method, handler) {
+        if (!(method in this._messageHandlers)) {
+            this._messageHandlers[method] = new signal_1.Signal();
+        }
+        return this._messageHandlers[method].attach(handler);
+    }
+    _handleMessage(message) {
+        if (message.method) {
+            const { method, params } = message;
+            const handlers = this._messageHandlers[method];
+            if (handlers) {
+                handlers.dispatch(...params);
+            }
+        }
+        else {
+            const { id } = message;
+            const responseHandler = this._responseHandlers[id];
+            if (!responseHandler) {
+                return;
+            }
+            if ('result' in message) {
+                responseHandler.resolve(message.result);
+            }
+            else if ('error' in message) {
+                // TODO We should wrap this in an Error instance
+                responseHandler.reject(message.error);
+            }
+            delete this._responseHandlers[id];
+        }
+    }
+}
+exports.Channel = Channel;
+const messageCounter = createMessageCounter();
+function createMessageCounter() {
+    let messageCount = 0;
+    return {
+        getMessageId: () => messageCount++,
+    };
+}
+function createSender(sourceId, targetWindow) {
+    return function send(method, params) {
+        const messageId = messageCounter.getMessageId();
+        try {
+            targetWindow.postMessage({
+                source: sourceId,
+                id: messageId,
+                method,
+                params,
+            }, '*');
+        }
+        catch (e) {
+            if (e instanceof DOMException && e.name === 'DataCloneError' && method === 'openDialog') {
+                console.error('Error: openCurrent[App] parameters could not be parsed. You likely tried to pass functions or DOM elements as a parameter. Tip: Use the App SDK directly within the dialog location.\n\nLearn more about the dialog location: https://ctfl.io/app-sdk-dialog');
+            }
+            throw e;
+        }
+        return messageId;
+    };
+}
+function sendInitMessage(currentGlobal) {
+    const messageId = messageCounter.getMessageId();
+    const targetWindow = currentGlobal.parent;
+    // The app is not connected yet so we can't provide a `source`
+    targetWindow.postMessage({
+        id: messageId,
+        method: 'init',
+        params: [],
+    }, '*');
+    return messageId;
+}
+exports.sendInitMessage = sendInitMessage;

package/dist/cma.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCMAClient = void 0;
+const contentful_management_1 = require("contentful-management");
+const cmaAdapter_1 = require("./cmaAdapter");
+function createCMAClient(ids, channel) {
+    return (0, contentful_management_1.createClient)({ apiAdapter: (0, cmaAdapter_1.createAdapter)(channel) }, {
+        type: 'plain',
+        defaults: {
+            environmentId: ids.environmentAlias ?? ids.environment,
+            spaceId: ids.space,
+            organizationId: ids.organization,
+        },
+    });
+}
+exports.createCMAClient = createCMAClient;

package/dist/cmaAdapter.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAdapter = void 0;
+const createMakeRequestCall = (channel) => {
+    return (opts) => channel.call('CMAAdapterCall', opts);
+};
+function createAdapter(channel) {
+    return {
+        makeRequest: createMakeRequestCall(channel),
+    };
+}
+exports.createAdapter = createAdapter;

package/dist/dialogs.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const isObject = (o) => typeof o === 'object' && o !== null && !Array.isArray(o);
+const prepareOptions = (options) => (isObject(options) ? options : {});
+function createDialogs(channel, ids) {
+    return {
+        openAlert: openSimpleDialog.bind(null, 'alert'),
+        openConfirm: openSimpleDialog.bind(null, 'confirm'),
+        openPrompt: openSimpleDialog.bind(null, 'prompt'),
+        open: open,
+        selectSingleEntry: openEntitySelector.bind(null, 'Entry', false),
+        selectSingleAsset: openEntitySelector.bind(null, 'Asset', false),
+        selectMultipleEntries: openEntitySelector.bind(null, 'Entry', true),
+        selectMultipleAssets: openEntitySelector.bind(null, 'Asset', true),
+    };
+    function openSimpleDialog(type, options) {
+        return channel.call('openDialog', type, prepareOptions(options));
+    }
+    function open(options) {
+        options = prepareOptions(options);
+        if (ids.app) {
+            // Force ID of the current app.
+            const withForcedId = { ...options, id: ids.app };
+            return channel.call('openDialog', 'app', withForcedId);
+        }
+        else {
+            throw new Error('Not in the app context.');
+        }
+    }
+    function openEntitySelector(entityType, multiple, options) {
+        options = prepareOptions(options);
+        options.entityType = entityType;
+        options.multiple = multiple;
+        return channel.call('openDialog', 'entitySelector', options);
+    }
+}
+exports.default = createDialogs;

package/dist/editor.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const signal_1 = require("./signal");
+function createEditor(channel, editorInterface, editorData) {
+    const localeSettingsSignal = new signal_1.MemoizedSignal(editorData.localeSettings);
+    const showHiddenFieldsSignal = new signal_1.MemoizedSignal(editorData.showHiddenFields);
+    channel.addHandler('localeSettingsChanged', (settings) => {
+        localeSettingsSignal.dispatch(settings);
+    });
+    channel.addHandler('showHiddenFieldsChanged', (showHiddenFields) => {
+        showHiddenFieldsSignal.dispatch(showHiddenFields);
+    });
+    return {
+        editorInterface,
+        getLocaleSettings() {
+            return localeSettingsSignal.getMemoizedArgs()[0];
+        },
+        onLocaleSettingsChanged: (handler) => {
+            return localeSettingsSignal.attach(handler);
+        },
+        getShowHiddenFields() {
+            return showHiddenFieldsSignal.getMemoizedArgs()[0];
+        },
+        onShowHiddenFieldsChanged: (handler) => {
+            return showHiddenFieldsSignal.attach(handler);
+        },
+    };
+}
+exports.default = createEditor;

package/dist/entry.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const signal_1 = require("./signal");
+const taskMethods = [
+    'getTask',
+    'getTasks',
+    'createTask',
+    'updateTask',
+    'deleteTask',
+];
+function createEntry(channel, entryData, fieldInfo, createEntryField) {
+    let sys = entryData.sys;
+    const sysChanged = new signal_1.MemoizedSignal(sys);
+    let metadata = entryData.metadata;
+    const metadataChanged = new signal_1.MemoizedSignal(metadata);
+    channel.addHandler('sysChanged', (newSys) => {
+        sys = newSys;
+        sysChanged.dispatch(sys);
+    });
+    channel.addHandler('metadataChanged', (newMetadata) => {
+        metadata = newMetadata;
+        metadataChanged.dispatch(metadata);
+    });
+    const taskApi = {};
+    taskMethods.forEach((methodName) => {
+        taskApi[methodName] = function (...args) {
+            return channel.call('callEntryMethod', methodName, args);
+        };
+    });
+    return {
+        getSys() {
+            return sys;
+        },
+        publish(options) {
+            return channel.call('callEntryMethod', 'publish', [options]);
+        },
+        unpublish() {
+            return channel.call('callEntryMethod', 'unpublish');
+        },
+        save() {
+            return channel.call('callEntryMethod', 'save');
+        },
+        onSysChanged(handler) {
+            return sysChanged.attach(handler);
+        },
+        fields: fieldInfo.reduce((acc, info) => {
+            acc[info.id] = createEntryField(info);
+            return acc;
+        }, {}),
+        ...(metadata ? { metadata } : {}),
+        getMetadata() {
+            return metadata;
+        },
+        onMetadataChanged(handler) {
+            return metadataChanged.attach(handler);
+        },
+        ...taskApi,
+    };
+}
+exports.default = createEntry;

package/dist/field-locale.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const signal_1 = require("./signal");
+class FieldLocale {
+    constructor(channel, info) {
+        this.id = info.id;
+        this.name = info.name;
+        this.locale = info.locale;
+        this.type = info.type;
+        this.required = info.required;
+        this.validations = info.validations;
+        if (info.type === 'Array') {
+            this.items = info.items;
+        }
+        if (info.type === 'Link') {
+            this.linkType = info.linkType;
+        }
+        this._value = info.value;
+        this._valueSignal = new signal_1.MemoizedSignal(this._value);
+        this._isDisabledSignal = new signal_1.MemoizedSignal(info.isDisabled);
+        this._schemaErrorsChangedSignal = new signal_1.MemoizedSignal(info.schemaErrors);
+        this._channel = channel;
+        channel.addHandler('valueChanged', (id, locale, value) => {
+            if (id === this.id && (!locale || locale === this.locale)) {
+                this._value = value;
+                this._valueSignal.dispatch(value);
+            }
+        });
+        channel.addHandler('isDisabledChangedForFieldLocale', (id, locale, isDisabled) => {
+            if (id === this.id && locale === this.locale) {
+                this._isDisabledSignal.dispatch(isDisabled);
+            }
+        });
+        channel.addHandler('schemaErrorsChangedForFieldLocale', (id, locale, errors) => {
+            if (id === this.id && locale === this.locale) {
+                this._schemaErrorsChangedSignal.dispatch(errors);
+            }
+        });
+    }
+    getValue() {
+        return this._value;
+    }
+    async setValue(value) {
+        this._value = value;
+        return await this._channel.call('setValue', this.id, this.locale, value);
+    }
+    async removeValue() {
+        this._value = undefined;
+        await this._channel.call('removeValue', this.id, this.locale);
+    }
+    setInvalid(isInvalid) {
+        return this._channel.call('setInvalid', isInvalid, this.locale);
+    }
+    onValueChanged(handler) {
+        return this._valueSignal.attach(handler);
+    }
+    getIsDisabled() {
+        return this._isDisabledSignal.getMemoizedArgs()[0];
+    }
+    onIsDisabledChanged(handler) {
+        return this._isDisabledSignal.attach(handler);
+    }
+    getSchemaErrors() {
+        return this._schemaErrorsChangedSignal.getMemoizedArgs()[0];
+    }
+    onSchemaErrorsChanged(handler) {
+        return this._schemaErrorsChangedSignal.attach(handler);
+    }
+}
+exports.default = FieldLocale;

package/dist/field.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const field_locale_1 = require("./field-locale");
+class Field {
+    constructor(channel, info, defaultLocale) {
+        this.id = info.id;
+        this.name = info.name;
+        this.locales = info.locales;
+        this.type = info.type;
+        this.required = info.required;
+        this.validations = info.validations;
+        if (info.type === 'Array') {
+            this.items = info.items;
+        }
+        if (info.type === 'Link') {
+            this.linkType = info.linkType;
+        }
+        this._defaultLocale = defaultLocale;
+        this._fieldLocales = info.locales.reduce((acc, locale) => {
+            const fieldLocale = new field_locale_1.default(channel, {
+                id: info.id,
+                name: info.name,
+                type: info.type,
+                required: info.required,
+                validations: info.validations,
+                locale,
+                items: info.type === 'Array' ? info.items : undefined,
+                linkType: info.type === 'Link' ? info.linkType : undefined,
+                value: info.values[locale],
+                isDisabled: info.isDisabled[locale],
+                schemaErrors: info.schemaErrors[locale],
+            });
+            return { ...acc, [locale]: fieldLocale };
+        }, {});
+        this.assertHasLocale(defaultLocale);
+    }
+    getValue(locale) {
+        return this._getFieldLocale(locale).getValue();
+    }
+    async setValue(value, locale) {
+        return await this._getFieldLocale(locale).setValue(value);
+    }
+    async removeValue(locale) {
+        await this.setValue(undefined, locale);
+    }
+    onValueChanged(locale, handler) {
+        const h = handler || locale;
+        if (!handler) {
+            locale = '';
+        }
+        return this._getFieldLocale(locale).onValueChanged(h);
+    }
+    onIsDisabledChanged(locale, handler) {
+        const h = handler || locale;
+        if (!handler) {
+            locale = '';
+        }
+        return this._getFieldLocale(locale).onIsDisabledChanged(h);
+    }
+    _getFieldLocale(locale) {
+        locale = locale || this._defaultLocale;
+        this.assertHasLocale(locale);
+        return this._fieldLocales[locale];
+    }
+    getForLocale(locale) {
+        if (!locale) {
+            throw new Error('getForLocale must be passed a locale');
+        }
+        return this._getFieldLocale(locale);
+    }
+    assertHasLocale(locale) {
+        if (!this._fieldLocales[locale]) {
+            throw new Error(`Unknown locale "${locale}" for field "${this.id}"`);
+        }
+    }
+}
+exports.default = Field;

package/dist/index.js

@@ -0,0 +1,23 @@
+"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 });
+exports.init = exports.locations = void 0;
+const initialize_1 = require("./initialize");
+const api_1 = require("./api");
+__exportStar(require("./types"), exports);
+var locations_1 = require("./locations");
+Object.defineProperty(exports, "locations", { enumerable: true, get: function () { return locations_1.default; } });
+exports.init = (0, initialize_1.createInitializer)(globalThis, api_1.default);