@fjell/client-api 4.4.13 → 4.4.15

package/dist/AItemAPI.d.ts

@@ -1,7 +1,7 @@
-import { Item, QueryParams } from '@fjell/core';
-import { HttpApi } from '@fjell/http-api';
-import { ClientApiOptions } from './ClientApiOptions';
-import { ClientApi } from './ClientApi';
+import { Item, QueryParams } from "@fjell/core";
+import { HttpApi } from "@fjell/http-api";
+import { ClientApiOptions } from "./ClientApiOptions";
+import { ClientApi } from "./ClientApi";
 export type PathNamesArray<L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> = ([L5] extends [never] ? ([L4] extends [never] ? ([L3] extends [never] ? ([L2] extends [never] ? ([L1] extends [never] ? [
     string
 ] : [

package/dist/CItemAPI.d.ts

@@ -1,8 +1,8 @@
-import { ComKey, Item, ItemQuery, LocKeyArray, PriKey } from '@fjell/core';
-import { HttpApi } from '@fjell/http-api';
-import { PathNamesArray } from './AItemAPI';
-import { ClientApi } from './ClientApi';
-import { ClientApiOptions } from './ClientApiOptions';
+import { ComKey, Item, ItemQuery, LocKeyArray, PriKey } from "@fjell/core";
+import { HttpApi } from "@fjell/http-api";
+import { PathNamesArray } from "./AItemAPI";
+import { ClientApi } from "./ClientApi";
+import { ClientApiOptions } from "./ClientApiOptions";
 export interface CItemApi<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> extends ClientApi<V, S, L1, L2, L3, L4, L5> {
     action: (ik: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, action: string, body: any) => Promise<V>;
     all: (query: ItemQuery, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<V[]>;

package/dist/ClientApi.d.ts

@@ -1,4 +1,4 @@
-import { ComKey, Item, ItemQuery, LocKeyArray, PriKey } from '@fjell/core';
+import { ComKey, Item, ItemQuery, LocKeyArray, PriKey } from "@fjell/core";
 export interface ClientApi<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> {
     action: (ik: ComKey<S, L1, L2, L3, L4, L5> | PriKey<S>, action: string, body?: any) => Promise<V>;
     all: (query: ItemQuery, locations?: LocKeyArray<L1, L2, L3, L4, L5> | []) => Promise<V[]>;

package/dist/ClientApiOptions.d.ts

@@ -1,6 +1,6 @@
-import { Item } from '@fjell/core';
-import { ClientApi } from './ClientApi';
-import { DeleteMethodOptions, GetMethodOptions, PostMethodOptions, PutMethodOptions } from '@fjell/http-api';
+import { Item } from "@fjell/core";
+import { ClientApi } from "./ClientApi";
+import { DeleteMethodOptions, GetMethodOptions, PostMethodOptions, PutMethodOptions } from "@fjell/http-api";
 export interface ClientApiOptions {
     readAuthenticated?: boolean;
     allAuthenticated?: boolean;

package/dist/Instance.d.ts

@@ -1,6 +1,6 @@
-import { Item } from '@fjell/core';
-import { Instance as BaseInstance, Coordinate, Registry } from '@fjell/registry';
-import { ClientApi } from './ClientApi';
+import { Item } from "@fjell/core";
+import { Instance as BaseInstance, Coordinate, Registry } from "@fjell/registry";
+import { ClientApi } from "./ClientApi";
 /**
  * The Client API Instance interface represents a client API model instance that extends the base Instance
  * from @fjell/registry and adds client API operations for interacting with remote data.

package/dist/InstanceFactory.d.ts

@@ -1,6 +1,6 @@
-import { Item } from '@fjell/core';
-import { ClientApi } from './ClientApi';
-import { InstanceFactory as BaseInstanceFactory } from '@fjell/registry';
+import { Item } from "@fjell/core";
+import { ClientApi } from "./ClientApi";
+import { InstanceFactory as BaseInstanceFactory } from "@fjell/registry";
 export type InstanceFactory<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> = (clientApi: ClientApi<V, S, L1, L2, L3, L4, L5>) => BaseInstanceFactory<S, L1, L2, L3, L4, L5>;
 /**
  * Factory function for creating client-api instances

package/dist/PItemAPI.d.ts

@@ -1,7 +1,7 @@
-import { ComKey, Item, ItemQuery, PriKey } from '@fjell/core';
-import { HttpApi } from '@fjell/http-api';
-import { ClientApi } from './ClientApi';
-import { ClientApiOptions } from './ClientApiOptions';
+import { ComKey, Item, ItemQuery, PriKey } from "@fjell/core";
+import { HttpApi } from "@fjell/http-api";
+import { ClientApi } from "./ClientApi";
+import { ClientApiOptions } from "./ClientApiOptions";
 export interface PItemApi<V extends Item<S>, S extends string> extends ClientApi<V, S> {
     action: (ik: PriKey<S> | ComKey<S, never, never, never, never, never>, action: string, body: any) => Promise<V>;
     all: (query: ItemQuery) => Promise<V[]>;

package/dist/Utilities.d.ts

@@ -1,4 +1,4 @@
-import { ComKey, Item, LocKeyArray, PriKey } from '@fjell/core';
+import { ComKey, Item, LocKeyArray, PriKey } from "@fjell/core";
 export interface Utilities<V extends Item<S, L1, L2, L3, L4, L5>, S extends string, L1 extends string = never, L2 extends string = never, L3 extends string = never, L4 extends string = never, L5 extends string = never> {
     verifyLocations: (locations: LocKeyArray<L1, L2, L3, L4, L5> | [] | never) => boolean;
     processOne: (apiCall: Promise<V>) => Promise<V>;

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-export type { CItemApi } from './CItemAPI';
-export type { PItemApi } from './PItemAPI';
-export type { ClientApi } from './ClientApi';
-export type { ClientApiOptions } from './ClientApiOptions';
-export { createCItemApi } from './CItemAPI';
-export { createPItemApi } from './PItemAPI';
+export type { CItemApi } from "./CItemAPI";
+export type { PItemApi } from "./PItemAPI";
+export type { ClientApi } from "./ClientApi";
+export type { ClientApiOptions } from "./ClientApiOptions";
+export { createCItemApi } from "./CItemAPI";
+export { createPItemApi } from "./PItemAPI";
 export * from './Instance';
 export * from './InstanceFactory';
 export * from './Registry';

package/dist/index.js

@@ -1,6 +1,545 @@
-export { createCItemApi } from './CItemAPI.js';
-export { createPItemApi } from './PItemAPI.js';
-export { createInstance } from './Instance.js';
-export { createInstanceFactory } from './InstanceFactory.js';
-export { createRegistry, createRegistryFactory } from './Registry.js';
+// src/ops/all.ts
+import {
+  queryToParams
+} from "@fjell/core";
+
+// src/logger.ts
+import Logging from "@fjell/logging";
+var LibLogger = Logging.getLogger("@fjell/client-api");
+var logger_default = LibLogger;
+
+// src/ops/all.ts
+var logger = logger_default.get("client-api", "ops", "all");
+var getAllOperation = (api, apiOptions, utilities) => {
+  const all = async (query = {}, locations = []) => {
+    utilities.verifyLocations(locations);
+    const loc = locations;
+    const params = queryToParams(query);
+    const requestOptions = Object.assign({}, apiOptions.getOptions, { isAuthenticated: apiOptions.allAuthenticated, params });
+    logger.default("all", { query, locations, requestOptions });
+    return utilities.validatePK(await utilities.processArray(
+      api.httpGet(
+        utilities.getPath(loc),
+        requestOptions
+      )
+    ));
+  };
+  return all;
+};
+
+// src/ops/action.ts
+var logger2 = logger_default.get("client-api", "ops", "action");
+var getActionOperation = (api, apiOptions, utilities) => {
+  const action = async (ik, action2, body = {}) => {
+    const requestOptions = Object.assign({}, apiOptions.postOptions, { isAuthenticated: apiOptions.writeAuthenticated });
+    logger2.default("action", { ik, action: action2, body, requestOptions });
+    return utilities.validatePK(
+      await utilities.processOne(
+        api.httpPost(
+          `${utilities.getPath(ik)}/${action2}`,
+          body,
+          requestOptions
+        )
+      )
+    );
+  };
+  return action;
+};
+
+// src/ops/allAction.ts
+var logger3 = logger_default.get("client-api", "ops", "allAction");
+var getAllActionOperation = (api, apiOptions, utilities) => {
+  const allAction = async (action, body = {}, locations = []) => {
+    const requestOptions = Object.assign({}, apiOptions.postOptions, { isAuthenticated: apiOptions.writeAuthenticated });
+    logger3.default("allAction", { action, body, locations, requestOptions });
+    utilities.verifyLocations(locations);
+    const loc = locations;
+    return utilities.validatePK(
+      await utilities.processArray(
+        api.httpPost(
+          utilities.getPath(loc),
+          body,
+          requestOptions
+        )
+      )
+    );
+  };
+  return allAction;
+};
+
+// src/ops/one.ts
+import {
+  queryToParams as queryToParams2
+} from "@fjell/core";
+var logger4 = logger_default.get("client-api", "ops", "one");
+var getOneOperation = (api, apiOptions, utilities) => {
+  const one = async (query = {}, locations = []) => {
+    utilities.verifyLocations(locations);
+    const loc = locations;
+    const params = queryToParams2(query);
+    const requestOptions = Object.assign({}, apiOptions.getOptions, { isAuthenticated: apiOptions.readAuthenticated, params });
+    logger4.default("one", { query, locations, requestOptions });
+    let item = null;
+    const items = utilities.validatePK(await utilities.processArray(
+      api.httpGet(
+        utilities.getPath(loc),
+        requestOptions
+      )
+    ));
+    if (items.length > 0) {
+      item = items[0];
+    }
+    return item;
+  };
+  return one;
+};
+
+// src/ops/create.ts
+var logger5 = logger_default.get("client-api", "ops", "create");
+var getCreateOperation = (api, apiOptions, utilities) => {
+  const create = async (item, locations = []) => {
+    const requestOptions = Object.assign({}, apiOptions.postOptions, { isAuthenticated: apiOptions.writeAuthenticated });
+    logger5.default("create", { item, locations, requestOptions });
+    utilities.verifyLocations(locations);
+    const loc = locations;
+    const created = utilities.validatePK(await utilities.processOne(api.httpPost(
+      utilities.getPath(loc),
+      item,
+      requestOptions
+    )));
+    return created;
+  };
+  return create;
+};
+
+// src/ops/update.ts
+var logger6 = logger_default.get("client-api", "ops", "update");
+var getUpdateOperation = (api, apiOptions, utilities) => {
+  const update = async (ik, item) => {
+    const requestOptions = Object.assign({}, apiOptions.putOptions, { isAuthenticated: apiOptions.writeAuthenticated });
+    logger6.default("update", { ik, item, requestOptions });
+    return utilities.validatePK(await utilities.processOne(
+      api.httpPut(
+        utilities.getPath(ik),
+        item,
+        requestOptions
+      )
+    ));
+  };
+  return update;
+};
+
+// src/ops/get.ts
+var logger7 = logger_default.get("client-api", "ops", "get");
+var getGetOperation = (api, apiOptions, utilities) => {
+  const get = async (ik) => {
+    const requestOptions = Object.assign({}, apiOptions.getOptions, { isAuthenticated: apiOptions.readAuthenticated });
+    logger7.default("get", { ik, requestOptions });
+    return utilities.validatePK(await utilities.processOne(
+      api.httpGet(
+        utilities.getPath(ik),
+        requestOptions
+      )
+    ));
+  };
+  return get;
+};
+
+// src/ops/remove.ts
+var logger8 = logger_default.get("client-api", "ops", "remove");
+var getRemoveOperation = (api, apiOptions, utilities) => {
+  const remove = async (ik) => {
+    const requestOptions = Object.assign({}, apiOptions.deleteOptions, { isAuthenticated: apiOptions.writeAuthenticated });
+    logger8.default("remove", { ik, requestOptions });
+    return api.httpDelete(utilities.getPath(ik), requestOptions);
+  };
+  return remove;
+};
+
+// src/ops/find.ts
+var logger9 = logger_default.get("client-api", "ops", "find");
+var getFindOperation = (api, apiOptions, utilities) => {
+  const find = async (finder, finderParams = {}, locations = []) => {
+    utilities.verifyLocations(locations);
+    const loc = locations;
+    const mergedParams = finderToParams(finder, finderParams);
+    const requestOptions = Object.assign({}, apiOptions.getOptions, { isAuthenticated: apiOptions.allAuthenticated, params: mergedParams });
+    logger9.default("find", { finder, finderParams, locations, requestOptions });
+    return utilities.validatePK(await utilities.processArray(
+      api.httpGet(
+        utilities.getPath(loc),
+        requestOptions
+      )
+    ));
+  };
+  return find;
+};
+
+// src/ops/findOne.ts
+var logger10 = logger_default.get("client-api", "ops", "find");
+var getFindOneOperation = (api, apiOptions, utilities) => {
+  const findOne = async (finder, finderParams = {}, locations = []) => {
+    utilities.verifyLocations(locations);
+    const loc = locations;
+    const params = finderToParams(finder, finderParams);
+    params.one = true;
+    const requestOptions = Object.assign({}, apiOptions.getOptions, { isAuthenticated: apiOptions.allAuthenticated, params });
+    logger10.default("findOne", { finder, finderParams, locations, requestOptions });
+    return utilities.validatePK(await utilities.processArray(
+      api.httpGet(
+        utilities.getPath(loc),
+        requestOptions
+      )
+    ))[0];
+  };
+  return findOne;
+};
+
+// src/ops/facet.ts
+var logger11 = logger_default.get("client-api", "ops", "facet");
+var getFacetOperation = (api, apiOptions, utilities) => {
+  const facet = async (ik, facet2, params = {}) => {
+    const requestOptions = Object.assign({}, apiOptions.getOptions, { isAuthenticated: apiOptions.writeAuthenticated, params });
+    logger11.default("facet", { ik, facet: facet2, requestOptions });
+    return api.httpGet(
+      `${utilities.getPath(ik)}/${facet2}`,
+      requestOptions
+    );
+  };
+  return facet;
+};
+
+// src/ops/allFacet.ts
+var logger12 = logger_default.get("client-api", "ops", "allFacet");
+var getAllFacetOperation = (api, apiOptions, utilities) => {
+  const allFacet = async (facet, params = {}, locations = []) => {
+    const requestOptions = Object.assign({}, apiOptions.getOptions, { isAuthenticated: apiOptions.writeAuthenticated, params });
+    logger12.default("allFacet", { facet, locations, requestOptions });
+    utilities.verifyLocations(locations);
+    const loc = locations;
+    return api.httpGet(
+      utilities.getPath(loc),
+      requestOptions
+    );
+  };
+  return allFacet;
+};
+
+// src/ops/index.ts
+var getOperations = (api, apiOptions, utilities) => {
+  return {
+    action: getActionOperation(
+      api,
+      apiOptions,
+      utilities
+    ),
+    all: getAllOperation(
+      api,
+      apiOptions,
+      utilities
+    ),
+    allAction: getAllActionOperation(
+      api,
+      apiOptions,
+      utilities
+    ),
+    allFacet: getAllFacetOperation(
+      api,
+      apiOptions,
+      utilities
+    ),
+    create: getCreateOperation(
+      api,
+      apiOptions,
+      utilities
+    ),
+    facet: getFacetOperation(
+      api,
+      apiOptions,
+      utilities
+    ),
+    findOne: getFindOneOperation(
+      api,
+      apiOptions,
+      utilities
+    ),
+    find: getFindOperation(
+      api,
+      apiOptions,
+      utilities
+    ),
+    get: getGetOperation(
+      api,
+      apiOptions,
+      utilities
+    ),
+    one: getOneOperation(
+      api,
+      apiOptions,
+      utilities
+    ),
+    remove: getRemoveOperation(
+      api,
+      apiOptions,
+      utilities
+    ),
+    update: getUpdateOperation(
+      api,
+      apiOptions,
+      utilities
+    )
+  };
+};
+
+// src/Utilities.ts
+import {
+  validatePK as coreValidatePK,
+  generateKeyArray,
+  isPriKey
+} from "@fjell/core";
+import deepmerge from "deepmerge";
+var logger13 = logger_default.get("client-api", "Utility");
+var createUtilities = (pkType, pathNames) => {
+  logger13.default("createUtilities", { pkType, pathNames });
+  const verifyLocations = (locations) => {
+    if (locations && locations.length < pathNames.length - 1) {
+      throw new Error("Not enough locations for pathNames: locations:" + locations.length + " pathNames:" + pathNames.length);
+    }
+    return true;
+  };
+  const processOne = async (apiCall) => {
+    logger13.default("processOne", { apiCall });
+    const response = await apiCall;
+    logger13.default("processOne response", { response: JSON.stringify(response, null, 2) });
+    return convertDoc(response);
+  };
+  const processArray = async (api) => {
+    logger13.default("processArray", { api });
+    const response = await api;
+    logger13.default("processArray response", { response: JSON.stringify(response, null, 2) });
+    if (response && Array.isArray(response)) {
+      return response.map(
+        (subjectChat) => convertDoc(subjectChat)
+      );
+    } else {
+      logger13.error("Response was not an array", { response });
+      throw new Error("Response was not an array");
+    }
+  };
+  const convertDoc = (doc) => {
+    logger13.default("convertDoc", { doc });
+    if (doc && doc.events) {
+      const events = doc.events;
+      for (const key in events) {
+        events[key] = deepmerge(events[key], { at: events[key].at ? new Date(events[key].at) : null });
+      }
+      return doc;
+    } else {
+      return doc;
+    }
+  };
+  const getPath = (key) => {
+    const localPathNames = [...pathNames];
+    logger13.default("getPath", { key, pathNames: localPathNames });
+    const keys = generateKeyArray(key);
+    let path = addPath("", keys, localPathNames);
+    if (localPathNames.length === 1) {
+      path = `${path}/${localPathNames[0]}`;
+    }
+    logger13.default("getPath created", { key, path });
+    return path;
+  };
+  const addPath = (base, keys, localPathNames) => {
+    logger13.default("addPath", { base, keys, pathNames: localPathNames });
+    if (keys.length < localPathNames.length - 1) {
+      logger13.error(
+        "addPath should never have keys with a length less than the length of pathNames - 1",
+        { keys, localPathNames }
+      );
+      throw new Error("addPath should never have keys with a length less than the length of pathNames - 1: " + keys.length + " " + localPathNames.length + " " + JSON.stringify(keys, localPathNames));
+    } else if (keys.length > localPathNames.length) {
+      logger13.error(
+        "addPath should never have keys with a length greater than the length of pathNames",
+        { keys, pathNames }
+      );
+      throw new Error("addPath should never have keys with a length greater than the length of pathNames: " + keys.length + " " + localPathNames.length + " " + JSON.stringify(keys, localPathNames));
+    }
+    if (keys.length === 0) {
+      logger13.default("addPath returning base", { base });
+      return base;
+    } else {
+      let nextBase;
+      const key = keys.pop();
+      const pathName = localPathNames.pop();
+      if (isPriKey(key)) {
+        const PriKey2 = key;
+        nextBase = `${base}/${pathName}/${PriKey2.pk}`;
+        logger13.default("Adding Path for PK", { pathName, PriKey: PriKey2, nextBase });
+      } else {
+        const LocKey2 = key;
+        nextBase = `${base}/${pathName}/${LocKey2.lk}`;
+        logger13.default("Retrieving Collection for LK", { pathName, LocKey: LocKey2 });
+      }
+      logger13.default("calling addPath recursively", { nextBase, keys, localPathNames });
+      return addPath(nextBase, keys, localPathNames);
+    }
+  };
+  const validatePK = (item) => {
+    return coreValidatePK(item, pkType);
+  };
+  return {
+    verifyLocations,
+    processOne,
+    convertDoc,
+    processArray,
+    getPath,
+    validatePK
+  };
+};
+
+// src/AItemAPI.ts
+var logger14 = logger_default.get("AItemAPI");
+var finderToParams = (finder, finderParams) => {
+  return {
+    finder,
+    finderParams: JSON.stringify(finderParams)
+  };
+};
+var createAItemAPI = (api, pkType, pathNames, options) => {
+  logger14.default("createAItemAPI", { pkType, pathNames, options });
+  let mergedOptions;
+  const defaultOptions = {
+    readAuthenticated: true,
+    allAuthenticated: true,
+    writeAuthenticated: true,
+    getOptions: {},
+    postOptions: {},
+    putOptions: {},
+    deleteOptions: {}
+  };
+  if (options) {
+    mergedOptions = Object.assign({}, defaultOptions, options);
+  } else {
+    mergedOptions = defaultOptions;
+  }
+  const utilities = createUtilities(pkType, pathNames);
+  const operations = getOperations(api, mergedOptions, utilities);
+  return {
+    action: operations.action,
+    all: operations.all,
+    allAction: operations.allAction,
+    allFacet: operations.allFacet,
+    create: operations.create,
+    facet: operations.facet,
+    find: operations.find,
+    findOne: operations.findOne,
+    get: operations.get,
+    one: operations.one,
+    remove: operations.remove,
+    update: operations.update
+  };
+};
+
+// src/CItemAPI.ts
+var logger15 = logger_default.get("CItemAPI");
+var createCItemApi = (api, type, pathNames, options) => {
+  logger15.default("createCItemApi", { api, type, pathNames, options });
+  const aItemAPI = createAItemAPI(api, type, pathNames, options);
+  return {
+    action: aItemAPI.action,
+    all: aItemAPI.all,
+    allAction: aItemAPI.allAction,
+    allFacet: aItemAPI.allFacet,
+    one: aItemAPI.one,
+    get: aItemAPI.get,
+    create: aItemAPI.create,
+    remove: aItemAPI.remove,
+    update: aItemAPI.update,
+    facet: aItemAPI.facet,
+    find: aItemAPI.find,
+    findOne: aItemAPI.findOne
+  };
+};
+
+// src/PItemAPI.ts
+var logger16 = logger_default.get("PItemAPI");
+var createPItemApi = (api, type, pathName, options) => {
+  logger16.default("createPItemApi", { type, pathName, options });
+  const aItemAPI = createAItemAPI(api, type, [pathName], options);
+  const action = async (ik, action2, body = {}) => await aItemAPI.action(ik, action2, body);
+  const all = async (query = {}) => await aItemAPI.all(query, []);
+  const allAction = async (action2, body = {}) => await aItemAPI.allAction(action2, body, []);
+  const allFacet = async (facet2, params = {}) => await aItemAPI.allFacet(facet2, params);
+  const one = async (query = {}) => await aItemAPI.one(query, []);
+  const get = async (ik) => await aItemAPI.get(ik);
+  const create = async (item) => await aItemAPI.create(item, []);
+  const remove = async (ik) => await aItemAPI.remove(ik);
+  const update = async (ik, item) => await aItemAPI.update(ik, item);
+  const facet = async (ik, facet2, params = {}) => await aItemAPI.facet(ik, facet2, params);
+  const find = async (finder, finderParams = {}) => await aItemAPI.find(finder, finderParams);
+  const findOne = async (finder, finderParams = {}) => await aItemAPI.findOne(finder, finderParams);
+  return {
+    ...aItemAPI,
+    action,
+    all,
+    allAction,
+    allFacet,
+    one,
+    get,
+    create,
+    remove,
+    update,
+    facet,
+    find,
+    findOne
+  };
+};
+
+// src/Instance.ts
+import { createInstance as createBaseInstance } from "@fjell/registry";
+var logger17 = logger_default.get("Instance");
+var createInstance = (registry, coordinate, clientApi) => {
+  logger17.debug("createInstance", { coordinate, clientApi, registry });
+  const baseInstance = createBaseInstance(registry, coordinate);
+  return { ...baseInstance, clientApi };
+};
+
+// src/InstanceFactory.ts
+var logger18 = logger_default.get("InstanceFactory");
+var createInstanceFactory = (clientApi) => {
+  return (coordinate, context) => {
+    logger18.debug("Creating client-api instance", { coordinate, registry: context.registry, clientApi });
+    return createInstance(context.registry, coordinate, clientApi);
+  };
+};
+
+// src/Registry.ts
+import {
+  createRegistry as createBaseRegistry
+} from "@fjell/registry";
+var logger19 = logger_default.get("Registry");
+var createRegistryFactory = () => {
+  return (type, registryHub) => {
+    if (type !== "client-api") {
+      throw new Error(`Client API registry factory can only create 'client-api' type registries, got: ${type}`);
+    }
+    logger19.debug("Creating client-api registry", { type, registryHub });
+    const baseRegistry = createBaseRegistry(type, registryHub);
+    return baseRegistry;
+  };
+};
+var createRegistry = (registryHub) => {
+  const baseRegistry = createBaseRegistry("client-api", registryHub);
+  return {
+    ...baseRegistry
+  };
+};
+export {
+  createCItemApi,
+  createInstance,
+  createInstanceFactory,
+  createPItemApi,
+  createRegistry,
+  createRegistryFactory
+};
 //# sourceMappingURL=index.js.map