Function lazyLoad

lib/container.js:541–642

(name)

  }

  function lazyLoad(name) {
    return new Proxy(
      {},
      {
        get(target, prop) {
          // behavr like array or
          if (prop === 'length') return Object.keys(config).length
          if (prop === Symbol.iterator) {
            return function* () {
              for (let i = 0; i < Object.keys(config).length; i++) {
                yield target[i]
              }
            }
          }

          // load actual name from vocabulary
          if (container.translation && container.translation.I && name === 'I') {
            // Use translated name for I
            const actualName = container.translation.I
            if (actualName !== 'I') {
              name = actualName
            }
          }

          if (name === 'I') {
            if (!container.support.I) {
              // Actor will be created during container.create()
              return undefined
            }
            methodsOfObject(container.support.I)
            return container.support.I[prop]
          }

          if (!container.support[name] && typeof config[name] === 'object') {
            container.support[name] = config[name]
          }

          if (!container.support[name]) {
            // Cannot load object synchronously in proxy getter
            // Return undefined and log warning - object should be pre-loaded during container creation
            debug(`Support object ${name} not pre-loaded, returning undefined`)
            return undefined
          }

          const currentObject = container.support[name]
          let currentValue = currentObject[prop]

          if (isFunction(currentValue) || isAsyncFunction(currentValue)) {
            if (prop.toString().charAt(0) !== '_' && currentObject._before && !beforeCalledSet.has(name)) {
              beforeCalledSet.add(name)
              const originalValue = currentValue
              const wrappedValue = async function (...args) {
                await currentObject._before()
                return originalValue.apply(currentObject, args)
              }
              const ms = new MetaStep(name, prop)
              ms.setContext(currentObject)
              debug(`metastep is created for ${name}.${prop.toString()}() (with _before)`)