@owlmeans/context 0.1.18-rc.3 → 0.1.18-rc.30

package/src/context.ts

@@ -1,19 +1,21 @@
-import { ContextStage, Layer, MiddlewareStage, MiddlewareType } from './consts.js'
-import type { BasicConfig, BasicContext, Middleware, BasicEntrypoint, BasicModule, BasicResource, Service } from './types.js'
-// import { applyMiddlewares, getAllServices, getMiddlerwareKey, isResourceAvailable, layersOrder } from './utils/context.js'
-import { applyMiddlewares, getAllServices, getMiddlerwareKey, isResourceAvailable } from './utils/context.js'
-import { DEFAULT, InLayer, initializeLayer } from './utils/layer.js'
+import { ContextStage, MiddlewareStage, MiddlewareType } from './consts.js'
+import type {
+  BasicConfig, BasicContext, Middleware, BasicEntrypoint, BasicResource, EntrypointReference, Service
+} from './types.js'
+import { applyMiddlewares, getMiddlerwareKey } from './utils/context.js'
 
 type Entrypoint = BasicEntrypoint
 
 export const makeBasicContext = <C extends BasicConfig>(cfg: C): BasicContext<C> => {
-  const services = {} as InLayer<Record<string, Service>>
-  const entrypoints = {} as InLayer<Record<string, Entrypoint>>
-  const resources = {} as InLayer<Record<string, BasicResource>>
+  /**
+   * One flat registry per kind, keyed by alias. Registering an alias twice replaces the
+   * earlier entry — application entrypoint lists are routinely spread together and the
+   * later declaration is the one the app means.
+   */
+  const services: Record<string, Service> = {}
+  const entrypoints: Record<string, Entrypoint> = {}
+  const resources: Record<string, BasicResource> = {}
   const middlewares: Record<string, Middleware[]> = {}
-  const allServices: Record<string, Service> = {}
-  const allEntrypoints: Record<string, Entrypoint> = {}
-  const allResources: Record<string, BasicResource> = {}
 
   let configure: (res: boolean) => void
   let initialize: (resv: boolean) => void
@@ -21,8 +23,6 @@ export const makeBasicContext = <C extends BasicConfig>(cfg: C): BasicContext<C>
   const configured = new Promise<boolean>(resolve => { configure = resolve })
   const initialized = new Promise<boolean>(resolve => { initialize = resolve })
 
-  // const contexts: Record<string, BasicContext<C>> = {}
-
   const inLazyInit = new Set<Service>()
 
   const context: BasicContext<C> = {
@@ -59,7 +59,7 @@ export const makeBasicContext = <C extends BasicConfig>(cfg: C): BasicContext<C>
 
       await applyMiddlewares<C, BasicContext<C>>(context, middlewares, MiddlewareType.Context, MiddlewareStage.Configuration)
 
-      await getAllServices(services, context.cfg.layer, context.cfg.layerId ?? DEFAULT).reduce(
+      await Object.values(services).reduce(
         async (previous, service) => {
           await previous
           if (!service.initialized) {
@@ -75,12 +75,9 @@ export const makeBasicContext = <C extends BasicConfig>(cfg: C): BasicContext<C>
 
       await applyMiddlewares<C, BasicContext<C>>(context, middlewares, MiddlewareType.Config, MiddlewareStage.Loading)
 
-      const id = initializeLayer(resources, context.cfg.layer, context.cfg.layerId ?? DEFAULT)
-      await Object.values(resources[context.cfg.layer][id]).reduce(async (previous, resource) => {
+      await Object.values(resources).reduce(async (previous, resource) => {
         await previous
-        if (isResourceAvailable(resource, context.cfg.layer)) {
-          await resource.init?.()
-        }
+        await resource.init?.()
       }, Promise.resolve())
 
       await applyMiddlewares<C, BasicContext<C>>(context, middlewares, MiddlewareType.Context, MiddlewareStage.Loading)
@@ -95,24 +92,13 @@ export const makeBasicContext = <C extends BasicConfig>(cfg: C): BasicContext<C>
     },
 
     registerService: <T>(service: Service) => {
-      const id = initializeLayer(services, context.cfg.layer, context.cfg.layerId)
-      service = service.registerContext(context)
-
-      if (allServices[service.alias] == null) {
-        allServices[service.alias] = service
-      }
-      services[context.cfg.layer][id][service.alias] = service
+      services[service.alias] = service.registerContext(context)
 
       return context as T
     },
 
     registerEntrypoint: <T>(entrypoint: Entrypoint) => {
-      const id = initializeLayer(entrypoints, context.cfg.layer, context.cfg.layerId)
-      entrypoint = entrypoint.registerContext(context)
-      if (allEntrypoints[entrypoint.alias] == null) {
-        allEntrypoints[entrypoint.alias] = entrypoint
-      }
-      entrypoints[context.cfg.layer][id][entrypoint.alias] = entrypoint
+      entrypoints[entrypoint.alias] = entrypoint.registerContext(context)
 
       return context as T
     },
@@ -122,19 +108,8 @@ export const makeBasicContext = <C extends BasicConfig>(cfg: C): BasicContext<C>
       return context as T
     },
 
-    /** @deprecated use registerEntrypoint */
-    registerModule: <T>(module: BasicModule) => context.registerEntrypoint(module as unknown as Entrypoint) as T,
-
-    /** @deprecated use registerEntrypoints */
-    registerModules: <T>(mods: BasicModule[]) => context.registerEntrypoints(mods as unknown as Entrypoint[]) as T,
-
     registerResource: <T>(resource: BasicResource) => {
-      const id = initializeLayer(resources, context.cfg.layer, context.cfg.layerId)
-      resource = resource.registerContext(context)
-      if (allResources[resource.alias] == null) {
-        allResources[resource.alias] = resource
-      }
-      resources[context.cfg.layer][id][resource.alias] = resource
+      resources[resource.alias] = resource.registerContext(context)
 
       return context as T
     },
@@ -154,15 +129,9 @@ export const makeBasicContext = <C extends BasicConfig>(cfg: C): BasicContext<C>
     },
 
     service: <T>(alias: string) => {
-      const id = initializeLayer(services, context.cfg.layer, context.cfg.layerId)
-
-      let _service: Service
-      if (services[context.cfg.layer]?.[id]?.[alias] != null) {
-        _service = services[context.cfg.layer][id][alias]
-      } else if (services[Layer.Global]?.[id]?.[alias] != null) {
-        _service = services[context.cfg.layer][id][alias]
-      } else {
-        throw new SyntaxError(`Service ${alias} not found in layer ${context.cfg.layer}`)
+      const _service = services[alias]
+      if (_service == null) {
+        throw new SyntaxError(`Service ${alias} not found`)
       }
       if (!_service.initialized) {
         if (_service.lazyInit != null) {
@@ -179,99 +148,28 @@ export const makeBasicContext = <C extends BasicConfig>(cfg: C): BasicContext<C>
       return _service as T
     },
 
-    entrypoint: <T extends Entrypoint>(alias: string) => {
-      const id = initializeLayer(entrypoints, context.cfg.layer, context.cfg.layerId)
-      if (entrypoints[context.cfg.layer][id][alias] != null) {
-        return entrypoints[context.cfg.layer][id][alias] as T
+    entrypoint: <T extends Entrypoint>(reference: EntrypointReference<T> | string) => {
+      const alias = typeof reference === 'string' ? reference : reference.alias
+      if (entrypoints[alias] != null) {
+        return entrypoints[alias] as T
       }
       throw new SyntaxError(`Entrypoint ${alias} not found`)
     },
 
-    /** @deprecated use entrypoint */
-    module: <T>(alias: string) => context.entrypoint<any>(alias) as T,
-
     resource: <T extends BasicResource>(alias: string) => {
-      const id = initializeLayer(resources, context.cfg.layer, context.cfg.layerId)
-      if (resources[context.cfg.layer][id][alias] != null) {
-        const resource = resources[context.cfg.layer][id][alias] as T
-
-        return resource
+      if (resources[alias] != null) {
+        return resources[alias] as T
       }
       throw new SyntaxError(`Resource ${alias} not found`)
     },
 
-    entrypoints: <T extends Entrypoint>() => {
-      const id = initializeLayer(entrypoints, context.cfg.layer, context.cfg.layerId)
-      return Object.values(entrypoints[context.cfg.layer][id]) as T[]
-    },
-
-    /** @deprecated use entrypoints */
-    modules: <T>() => context.entrypoints<any>() as T[],
-
-    /**
-     * @TODO Unfortunatly module cloning between contexts is quite unstable.
-     * And it looks like in some cases it relies on modules that aren't really clonned.
-     * The problem is that the not cloned modules are changing their context accross all context
-     * layers and we can't rely on such behaviour.
-     * So we disabled context update as a whole and all functionality that relies on it
-     * cause in curent release mixed tenancy is not in use in any project and it looks like
-     * there is no short term plans to use it some way. 
-     */
-    updateContext: async <T>(_id?: string, _layer?: Layer) => {
-      return context as T
-
-      // const index = layersOrder.indexOf(context.cfg.layer)
-      // layer = layer ?? (layersOrder[index + 1] != null ? layersOrder[index + 1] : undefined)
-      // if (layer == null) {
-      //   throw new SyntaxError("There is no next layer to switch to")
-      // }
-
-      // if ([Layer.Entity, Layer.User].includes(layer) && id == null) {
-      //   throw new SyntaxError(`Cannot switch to layer ${layer} without id`)
-      // }
-
-      // id = initializeLayer(resources, layer, id)
-
-      // // Cache initalized context layers
-      // const key = `${layer}:${id}`
-      // if (key in contexts) {
-      //   return contexts[key] as T
-      // }
-
-      // const _config: C = JSON.parse(JSON.stringify(context.cfg))
-      // _config.layer = layer
-      // _config.ready = false
-      // _config.layerId = id
-      // // @TODO we need to make a rule to store all makeContext methods after they are applied
-      // const _context = context.makeContext != null ? context.makeContext(_config) : makeBasicContext(_config)
-
-      // Object.values(middlewares).flatMap(middlewares => middlewares)
-      //   .forEach(middleware => _context.registerMiddleware(middleware))
-
-      // await applyMiddlewares<C, BasicContext<C>>(_context, middlewares, MiddlewareType.Config, MiddlewareStage.Switching, { layer, id })
-
-      // Object.values(allServices).forEach(service => _context.registerService(service))
-
-      // Object.values(allEntrypoints).forEach(ep => _context.registerEntrypoint(ep))
-
-      // Object.values(allResources).forEach(resource => _context.registerResource(resource))
-
-      // await applyMiddlewares<C, BasicContext<C>>(_context, middlewares, MiddlewareType.Context, MiddlewareStage.Switching, { layer, id })
-
-      // _context.stage = ContextStage.Loading
-      // await _context.configure().init()
-
-      // return (contexts[key] = _context) as T
-    },
-
-    hasResource: alias => allResources[alias] != null,
+    entrypoints: <T extends Entrypoint>() => Object.values(entrypoints) as T[],
 
-    hasService: alias => allServices[alias] != null,
+    hasResource: alias => resources[alias] != null,
 
-    hasEntrypoint: alias => allEntrypoints[alias] != null,
+    hasService: alias => services[alias] != null,
 
-    /** @deprecated use hasEntrypoint */
-    hasModule: alias => context.hasEntrypoint(alias),
+    hasEntrypoint: alias => entrypoints[alias] != null,
   }
 
   return context

package/src/helper.ts

@@ -1,21 +1,14 @@
-import { Layer } from './consts.js'
 import type { Contextual, BasicContext, BasicConfig } from './types.js'
 
 export const appendContextual = <T extends Contextual>(alias: string, contextual: Partial<T>): T => {
   contextual.alias = alias
   contextual.registerContext = <T, C extends BasicConfig>(context: BasicContext<C>) => {
-    const _contextual = contextual.ctx == null
-      ? contextual
-      : contextual.reinitializeContext != null
-        ? contextual.reinitializeContext(context) : contextual
-
-    // We do NOT update context when it's the same contextual with already set context
-    // Actuall we just do not need to switch context in many on the level of context consumer
-    if (_contextual.ctx == null) {
-      _contextual.ctx = context
+    // A contextual binds to exactly one context — the first one that registers it.
+    if (contextual.ctx == null) {
+      contextual.ctx = context
     }
 
-    return _contextual as T
+    return contextual as T
   }
 
   contextual.assertCtx = (
@@ -25,10 +18,6 @@ export const appendContextual = <T extends Contextual>(alias: string, contextual
   return contextual as T
 }
 
-// export type UpdContextType<C extends Config, T extends Context<C>, ExtraType> = T & ExtraType
-
-// export type UpdConfigType<T extends Config, ExtraType> = T & ExtraType
-
 /**
  * @throws {SyntaxError}
  */
@@ -38,6 +27,3 @@ export const assertContext = <C extends BasicConfig, T extends BasicContext<C>>(
   }
   return ctx as T
 }
-
-export const isContextWithoutIds = <C extends BasicConfig, T extends BasicContext<C>>(context: T): boolean =>
-  [Layer.System, Layer.Global, Layer.Service].includes(context.cfg.layer)

package/src/types.ts

@@ -1,13 +1,11 @@
-import type { AppType, ContextStage, Layer, MiddlewareStage, MiddlewareType, CONFIG_RECORD } from './consts.js'
+import type { AppType, ContextStage, MiddlewareStage, MiddlewareType, CONFIG_RECORD } from './consts.js'
 
 export interface BasicConfig {
   ready: boolean
   service: string
   // Is used as username of the service (e.g. for looking up for autehntication keys)
   alias?: string
-  layer: Layer
   type: AppType
-  layerId?: string
   services?: Record<string, Object>
   [CONFIG_RECORD]?: ConfigRecord[]
   debug?: {
@@ -31,13 +29,11 @@ interface ConfigRecordItem extends Record<
 export interface Contextual {
   ctx?: BasicContext<any>
   alias: string
-  reinitializeContext?: <T extends Contextual>(context: BasicContext<any>) => T // This method is a fix to replace context inside closed scope
   registerContext: <T extends Contextual, C extends BasicConfig>(context: BasicContext<C>) => T
   assertCtx: <C extends BasicConfig, T extends BasicContext<C>>(location?: string) => T
 }
 
 export interface Service extends Contextual {
-  layers?: Layer[]
   initialized: boolean
   init?: () => Promise<void>
   lazyInit?: () => Promise<void>
@@ -56,17 +52,22 @@ export interface LazyService extends Service {
 
 export interface BasicEntrypoint extends Contextual {
   _entrypoint: true
-  _module: true
 }
 
-/** @deprecated use BasicEntrypoint */
-export interface BasicModule extends Contextual {
-  _module: true
+/**
+ * A stable reference to an entrypoint registered in a context.
+ *
+ * Contract packages use this instead of exporting raw alias strings.  The optional type member is
+ * deliberately phantom: it lets `context.entrypoint(protocol)` infer the context-bound module
+ * without changing the wire alias or adding registry-wide declaration merging.
+ */
+export interface EntrypointReference<T extends BasicEntrypoint = BasicEntrypoint> {
+  readonly alias: string
+  readonly entrypointType?: T
 }
 
 export interface BasicResource extends Contextual {
-  layers?: Layer[]
-  init?: () => Promise<void> // After context switch the resource should be able to reinitialize
+  init?: () => Promise<void>
 }
 
 export interface Middleware {
@@ -75,6 +76,12 @@ export interface Middleware {
   apply: <C extends BasicConfig, T extends BasicContext<C>>(context: T, args?: Record<string, string | undefined>) => Promise<void>
 }
 
+/**
+ * The DI container. One context is built per process by one factory: a layer specific
+ * factory composes the layer below it and then `append*` mixins register what the
+ * application needs. There is no child context and nothing is stored for re-creation —
+ * a service, a resource and an entrypoint each bind to exactly one context.
+ */
 export interface BasicContext<C extends BasicConfig> {
   cfg: C
   stage: ContextStage
@@ -82,7 +89,6 @@ export interface BasicContext<C extends BasicConfig> {
   waitForInitialized: () => Promise<boolean>
   configure: <T extends BasicContext<C>>() => T
   init: <T extends BasicContext<C>>() => Promise<T>
-  updateContext: <T extends BasicContext<C>>(id?: string, to?: Layer) => Promise<T>
   registerService: <T extends BasicContext<C>>(service: Service) => T
   registerEntrypoint: <T extends BasicContext<C>>(entrypoint: BasicEntrypoint) => T
   registerEntrypoints: <T extends BasicContext<C>>(entrypoints: BasicEntrypoint[]) => T
@@ -91,24 +97,14 @@ export interface BasicContext<C extends BasicConfig> {
 
   get config(): Promise<C>
   service: <T extends Service>(alias: string) => T
-  entrypoint: <T extends BasicEntrypoint>(alias: string) => T
+  entrypoint: {
+    <T extends BasicEntrypoint>(reference: EntrypointReference<T>): T
+    <T extends BasicEntrypoint>(reference: EntrypointReference | string): T
+  }
   resource: <T extends BasicResource>(alias: string) => T
   hasResource: (alias: string) => boolean
   hasService: (alias: string) => boolean
   hasEntrypoint: (alias: string) => boolean
 
   entrypoints: <T extends BasicEntrypoint>() => T[]
-
-  /** @deprecated use registerEntrypoint */
-  registerModule: <T extends BasicContext<C>>(module: BasicModule) => T
-  /** @deprecated use registerEntrypoints */
-  registerModules: <T extends BasicContext<C>>(modules: BasicModule[]) => T
-  /** @deprecated use entrypoint */
-  module: <T extends BasicModule>(alias: string) => T
-  /** @deprecated use hasEntrypoint */
-  hasModule: (alias: string) => boolean
-  /** @deprecated use entrypoints */
-  modules: <T extends BasicModule>() => T[]
-
-  makeContext?: <T extends BasicContext<C>>(cfg: C) => T
 }

package/src/utils/context.ts

@@ -1,28 +1,10 @@
-import { Layer, MiddlewareStage, MiddlewareType } from '../consts.js'
-import type { BasicConfig, BasicContext, Middleware, BasicResource, Service } from '../types.js'
-import type { InLayer } from './layer.js'
+import type { MiddlewareStage, MiddlewareType } from '../consts.js'
+import type { BasicConfig, BasicContext, Middleware } from '../types.js'
 
 export const getMiddlerwareKey = (middleware: Middleware) => createMiddlewareKey(middleware.type, middleware.stage)
 
 export const createMiddlewareKey = (type: MiddlewareType, stage: MiddlewareStage) => `${type}:${stage}`
 
-export const isLayerIherited = (current: Layer, parent: Layer): boolean =>
-  (current === parent) || (layersOrder.indexOf(parent) > layersOrder.indexOf(current))
-
-export const isResourceAvailable = (resource: BasicResource, layer: Layer) =>
-  resource.layers == null || resource.layers.some(_layer => isLayerIherited(_layer, layer))
-
-export const layersOrder = [
-  Layer.System,
-  Layer.Global,
-  Layer.Service,
-  Layer.Entity,
-  Layer.User
-]
-
-export const getAllServices = (services: InLayer<Record<string, Service>>, layer: Layer, id: string) => 
-  services?.[layer]?.[id] != null ? Object.values(services[layer][id]) : []
-
 export const applyMiddlewares = <C extends BasicConfig, T extends BasicContext<C>>(
   context: T,
   middlewares: Record<string, Middleware[]>,

package/src/utils/index.ts

@@ -1,3 +1,2 @@
 
 export * from './context.js'
-export * from './layer.js'

package/tests/context.ts

@@ -1,10 +1,9 @@
-import { AppType, Layer, makeBasicContext } from '@owlmeans/context'
+import { AppType, makeBasicContext } from '@owlmeans/context'
 import type { BasicConfig, BasicContext } from '@owlmeans/context'
 
 const baseConfig = (): BasicConfig => ({
   ready: false,
   service: 'test-context',
-  layer: Layer.Service,
   type: AppType.Backend,
 })
 

package/tests/service.spec.ts

@@ -5,7 +5,7 @@ import { makeTestCtx } from './context.js'
 describe('@owlmeans/context — service registration', () => {
   test('registers a service and resolves it by alias after initialization', async () => {
     const ctx = makeTestCtx()
-    const stub = createService('alpha', { layers: [] })
+    const stub = createService('alpha', {})
     ctx.registerService(stub)
     expect(ctx.hasService('alpha')).toBe(true)
     ctx.configure()

package/agent-meta/skills/context/SKILL.md

@@ -1,53 +0,0 @@
----
-name: context
-description: How to use @owlmeans/context — base context (DI container) factory, registerService(), service<T>() lookups, entrypoint<ClientEntrypoint<T>>() resolution. Auto-invoked when importing context primitives or building a makeContext factory.
-user-invocable: false
----
-<!-- AUTO-GENERATED — do not edit. Regenerate via sync-agent-meta. -->
-
-# @owlmeans/context
-
-**Layer:** Core
-**Install:** `"@owlmeans/context": "^0.1.18-rc.0"` in `dependencies`
-
-## Key Exports
-
-| Export | Description |
-|--------|-------------|
-| `Context<C>` types | Generic context interface (typed by Config) |
-| `makeBasicContext` | Low-level factory — usually you extend a layer-specific factory instead |
-| `registerService` (method) | Add a service to the DI container |
-| `service<T>(alias)` (method) | Resolve a service by alias |
-| `entrypoint<ClientEntrypoint<T>>(alias)` (method) | Resolve an entrypoint to call cross-service |
-| `Service` types | Service interface and lifecycle |
-| Constants | Built-in service/entrypoint aliases |
-
-## Usage
-
-Always extend a layer-specific factory (`@owlmeans/server-context`, `@owlmeans/web-panel`, etc.) rather than calling the basic factory directly. Always reassign `context.makeContext` so child contexts inherit the typed factory:
-
-```typescript
-import { makeBackendContext } from '@owlmeans/server-context'
-
-export const makeContext = <C extends Config, T extends Context<C>>(cfg: C): T => {
-  const context = makeBackendContext<C, T>(cfg)
-  context.registerService(makeMyService())
-  context.makeContext = makeContext as typeof context.makeContext
-  return context
-}
-```
-
-Resolve services and call cross-service entrypoints from a handler:
-
-```typescript
-const someService = ctx.service<MyService>(MY_SERVICE_ALIAS)
-
-const [response] = await ctx.entrypoint<ClientEntrypoint<ResponseType>>(
-  externalService.action.alias
-).call({ body: { ... } })
-```
-
-## Depends On
-
-- `@owlmeans/config` — context is parameterized by a Config
-- `@owlmeans/entrypoint` — `ClientEntrypoint<T>` type for cross-service calls

package/build/utils/layer.d.ts

@@ -1,6 +0,0 @@
-import { Layer } from '../consts';
-export interface InLayer<T> extends Record<Layer, Record<string, T>> {
-}
-export declare const initializeLayer: <T>(inLayer: InLayer<T>, layer: Layer, id: string | undefined) => string;
-export declare const DEFAULT = "default";
-//# sourceMappingURL=layer.d.ts.map

package/build/utils/layer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"layer.d.ts","sourceRoot":"","sources":["../../src/utils/layer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,WAAW,CAAA;AAEjC,MAAM,WAAW,OAAO,CAAC,CAAC,CAAE,SAAQ,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;CAAI;AAExE,eAAO,MAAM,eAAe,GAAI,CAAC,WAAW,OAAO,CAAC,CAAC,CAAC,SAAS,KAAK,MAAM,MAAM,GAAG,SAAS,KAAG,MAU9F,CAAA;AAED,eAAO,MAAM,OAAO,YAAY,CAAA"}

package/build/utils/layer.js

@@ -1,12 +0,0 @@
-export const initializeLayer = (inLayer, layer, id) => {
-    if (inLayer[layer] == null) {
-        inLayer[layer] = {};
-    }
-    id = id ?? DEFAULT;
-    if (inLayer[layer][id] == null) {
-        inLayer[layer][id] = {};
-    }
-    return id;
-};
-export const DEFAULT = 'default';
-//# sourceMappingURL=layer.js.map

package/build/utils/layer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"layer.js","sourceRoot":"","sources":["../../src/utils/layer.ts"],"names":[],"mappings":"AAIA,MAAM,CAAC,MAAM,eAAe,GAAG,CAAI,OAAmB,EAAE,KAAY,EAAE,EAAsB,EAAU,EAAE;IACtG,IAAI,OAAO,CAAC,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC;QAC3B,OAAO,CAAC,KAAK,CAAC,GAAG,EAAE,CAAA;IACrB,CAAC;IACD,EAAE,GAAG,EAAE,IAAI,OAAO,CAAA;IAClB,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC;QAC/B,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,GAAG,EAAO,CAAA;IAC9B,CAAC;IAED,OAAO,EAAE,CAAA;AACX,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,OAAO,GAAG,SAAS,CAAA"}

package/src/utils/layer.ts

@@ -1,17 +0,0 @@
-import { Layer } from '../consts'
-
-export interface InLayer<T> extends Record<Layer, Record<string, T>> { }
-
-export const initializeLayer = <T>(inLayer: InLayer<T>, layer: Layer, id: string | undefined): string => {
-  if (inLayer[layer] == null) {
-    inLayer[layer] = {}
-  }
-  id = id ?? DEFAULT
-  if (inLayer[layer][id] == null) {
-    inLayer[layer][id] = {} as T
-  }
-
-  return id
-}
-
-export const DEFAULT = 'default'