@mora-light/core/dist/core-f5df6b39.cjs.dev.js

Mora Light Core

'use strict';

require('@dfinity/agent');
var clones = require('./clones-e2de357d.cjs.dev.js');
var running = require('./running-e74432b2.cjs.dev.js');
require('@dfinity/principal');
var custom = require('./custom-21c4a1f8.cjs.dev.js');
var types_source_dist_moraLightCoreTypesSource = require('../types/source/dist/mora-light-core-types-source.cjs.dev.js');
require('safer-eval');
var types_transform_dist_moraLightCoreTypesTransform = require('../types/transform/dist/mora-light-core-types-transform.cjs.dev.js');

// transport value

// filter type
const isCandidType = item => custom.CANDID_TYPE_LIST.includes(item.type.type);
const isCustomType = item => custom.CUSTOM_TYPE_LIST.includes(item.type.type);

// filter type: identity
const isCustomIdentityType = item => 'identity' === item.type.type;

// check item
const isSameValueItemType = (item1, item2) => {
  if (item1.name !== item2.name) return false;
  if (isCandidType(item1) && isCandidType(item2)) {
    if (!running.isSameCandidType(item1.type, item2.type)) return false;
    return true;
  }
  if (isCustomIdentityType(item1) && isCustomIdentityType(item2)) {
    return true;
  }
  return false;
};

// compare value
const getValueItem = (nv, ov) => {
  if (ov === undefined) return nv;
  if (nv.name !== ov.name) return nv;
  if (!isSameValueItemType(nv, ov)) return nv;
  return ov;
};

// =========================== light inner value ===========================

// find exported inner value
const findInnerValueItemsByLightCore = (light, values) => {
  const valueItems = [];
  for (let i = 0; i < light.data.length; i++) {
    findInnerValueItemsByDataSource(light.data[i], values, valueItems); // find exported inner value from data source
  }

  return valueItems;
};

// find exported inner value from data source
const findInnerValueItemsByDataSource = (source, values, valueItems) => {
  switch (source.source) {
    case 'light':
      // light has arg
      findInnerValueItemsByArgumentConstraint(source.light.arg, values, valueItems);
      break;
    case 'combined':
      // combined has arg
      findInnerValueItemsByArgumentConstraint(source.combined.arg, values, valueItems);
      break;
    case 'canister':
      // canister has arg
      findInnerValueItemsByArgumentConstraint(source.canister.arg, values, valueItems);
      switch (source.canister.identity.from) {
        case 'login':
        case 'host-login':
        case 'inner':
          if (source.canister.identity.exported?.target === 'inner') {
            // canister's identity cloud be exported
            if (source.canister.identity.from === 'inner') {
              // find pervious exported inner value if from is inner
              let chosen = valueItems.filter(valueItem => valueItem.name === source.canister.identity.name).filter(valueItem => isCustomIdentityType(valueItem));
              if (chosen.length) {
                const item = chosen[0];
                const detail = item.detail;
                valueItems.push({
                  name: source.canister.identity.exported.name,
                  type: {
                    type: 'identity'
                  },
                  detail,
                  extra: {
                    constant: false
                  } // not sure
                });
              }
            } else {
              const detail = source.canister.identity.from;
              valueItems.push({
                name: source.canister.identity.exported.name,
                type: {
                  type: 'identity'
                },
                detail,
                extra: {
                  constant: false
                } // not sure
              });
            }
          }
      }

      break;
  }
  valueItems.push(...findInnerValueItemsByExported(source, values)); // insert exported inner value if found
};

// find exported inner value from argument constraint
const findInnerValueItemsByArgumentConstraint = (arg, values, valueItems) => {
  switch (arg.constraint.type) {
    case 'force':
      findInnerValueItemsByDataSource(arg.constraint.source, values, valueItems);
      break;
    case 'blob':
      if (arg.constraint.length) {
        findInnerValueItemsByDataSource(arg.constraint.length, values, valueItems);
      }

      // only constant
      if (arg.constraint.constant > 0 && arg.constraint.subitems) {
        for (let i = 0; i < arg.constraint.constant; i++) {
          const constraint = arg.constraint.subitems[i]?.constraint;
          if (constraint !== undefined) {
            findInnerValueItemsByArgumentConstraint(constraint, values, valueItems);
          }
        }
      }
      break;
    case 'vec':
      if (arg.constraint.length) {
        findInnerValueItemsByDataSource(arg.constraint.length, values, valueItems);
      }

      // only constant
      if (arg.constraint.constant > 0 && arg.constraint.subitems) {
        for (let i = 0; i < arg.constraint.constant; i++) {
          const constraint = arg.constraint.subitems[i]?.constraint;
          if (constraint !== undefined) {
            findInnerValueItemsByArgumentConstraint(constraint, values, valueItems);
          }
        }
      }
      break;
    case 'opt':
      if (arg.constraint.has) {
        findInnerValueItemsByDataSource(arg.constraint.has, values, valueItems);
      }

      // only constant
      if (arg.constraint.constant === 1) {
        findInnerValueItemsByArgumentConstraint(arg.constraint.value, values, valueItems);
      }
      break;
    case 'record':
      for (let i = 0; i < arg.constraint.subitems.length; i++) {
        findInnerValueItemsByArgumentConstraint(arg.constraint.subitems[i], values, valueItems);
      }
      break;
    case 'variant':
      if (arg.constraint.select) {
        findInnerValueItemsByDataSource(arg.constraint.select, values, valueItems);
      }

      // only constant
      if (arg.constraint.constant && arg.constraint.subitems) {
        for (let i = 0; i < arg.constraint.subitems.length; i++) {
          if (arg.constraint.constant === arg.type.subitems[i].key) {
            // only the chosen one
            findInnerValueItemsByArgumentConstraint(arg.constraint.subitems[i], values, valueItems);
            break;
          }
        }
      }
      break;
    case 'tuple':
      for (let i = 0; i < arg.constraint.subitems.length; i++) {
        findInnerValueItemsByArgumentConstraint(arg.constraint.subitems[i], values, valueItems);
      }
      break;
    case 'rec':
      findInnerValueItemsByArgumentConstraint(arg.constraint.value, values, valueItems);
      break;
  }
};

// find exported inner value from exported data
const findInnerValueItemsByExported = (source, values) => {
  const valueItems = [];
  if (source.exported?.target === 'inner') {
    // if export to inner
    let valueResult = findConstantValue(source, values);
    const sourceType = types_source_dist_moraLightCoreTypesSource.findDataSourceType(source); // find data source type
    const child = running.findAloneType(sourceType);
    const r = {
      name: source.exported.name,
      type: sourceType,
      extra: {
        constant: false
      } // default is dynamic
    };

    if (child.child) r.child = child.child;
    if (valueResult?.ok !== undefined) r.extra = {
      constant: true,
      runtime: valueResult
    }; // constant if found

    valueItems.push(r);
  }
  return valueItems;
};

// =========================== light outer value ===========================

// find exported outer value
const findOuterValueItemsByLightCore = (light, values) => {
  const innerValues = [];
  const valueItems = [];
  for (let i = 0; i < light.data.length; i++) {
    findInnerValueItemsByDataSource(light.data[i], values, innerValues);
    findOuterValueItemsByDataSource(light.data[i], {
      propValues: values.propValues,
      innerValues
    }, valueItems); // find exported outer value from data source
  }

  // try to find exported outer value from transmit=
  let {
    result: dataResult,
    runtime: runtimeResult
  } = parseLightCandidType(light.data, values); // find light's result type
  if (light.transform) {
    dataResult = types_transform_dist_moraLightCoreTypesTransform.findTransformToCandidType(light.transform);
    runtimeResult = undefined; // must be dynamic if there is transform
  }

  for (let i = 0; i < light.transmits.length; i++) {
    const transmit = light.transmits[i];
    if (transmit.transmit === 'outer') {
      let type = dataResult;
      let runtime = runtimeResult;
      if (transmit.transform) {
        type = types_transform_dist_moraLightCoreTypesTransform.findTransformToCandidType(transmit.transform);
        runtime = undefined; // must be dynamic if there is transform
      }

      const name = (transmit.exported.name ?? '').trim();
      if (name) {
        valueItems.push({
          name,
          type,
          child: running.findAloneType(type).child,
          extra: runtime?.ok !== undefined ? {
            constant: true,
            runtime
          } : {
            constant: false
          }
        });
      }
    }
  }
  return valueItems;
};
const findOuterValueItemsByDataSource = (source, values, valueItems) => {
  switch (source.source) {
    case 'light':
      // light has arg
      findInnerValueItemsByArgumentConstraint(source.light.arg, {
        propValues: values.propValues
      }, values.innerValues);
      findOuterValueItemsByArgumentConstraint(source.light.arg, values, valueItems);
      break;
    case 'combined':
      // combined has arg
      findInnerValueItemsByArgumentConstraint(source.combined.arg, {
        propValues: values.propValues
      }, values.innerValues);
      findOuterValueItemsByArgumentConstraint(source.combined.arg, values, valueItems);
      break;
    case 'canister':
      // canister has arg
      findInnerValueItemsByArgumentConstraint(source.canister.arg, {
        propValues: values.propValues
      }, values.innerValues);
      findOuterValueItemsByArgumentConstraint(source.canister.arg, values, valueItems);
      switch (source.canister.identity.from) {
        case 'login':
        case 'host-login':
        case 'inner':
          if (source.canister.identity.exported?.target === 'inner') {
            // canister's identity cloud be exported
            if (source.canister.identity.from === 'inner') {
              // find pervious exported inner value if from is inner
              let chosen = values.innerValues.filter(value => value.name === source.canister.identity.name).filter(value => isCustomIdentityType(value));
              if (chosen.length) {
                const item = chosen[0];
                const detail = item.detail;
                values.innerValues.push({
                  name: source.canister.identity.exported.name,
                  type: {
                    type: 'identity'
                  },
                  detail,
                  extra: {
                    constant: false
                  } // not sure
                });
              }
            } else {
              const detail = source.canister.identity.from;
              values.innerValues.push({
                name: source.canister.identity.exported.name,
                type: {
                  type: 'identity'
                },
                detail,
                extra: {
                  constant: false
                } // not sure
              });
            }
          }
      }

      switch (source.canister.identity.from) {
        case 'login':
        case 'host-login':
        case 'inner':
          if (source.canister.identity.exported?.target === 'outer') {
            // canister's identity cloud be exported
            const exportedName = (source.canister.identity.exported.name ?? '').trim();
            if (exportedName) {
              if (source.canister.identity.from === 'inner') {
                // find pervious exported inner value if from is inner
                let chosen = values.innerValues.filter(value => value.name === source.canister.identity.name).filter(value => isCustomIdentityType(value));
                if (chosen.length) {
                  const item = chosen[0];
                  const detail = item.detail;
                  valueItems.push({
                    name: exportedName,
                    type: {
                      type: 'identity'
                    },
                    detail,
                    extra: {
                      constant: false
                    } // not sure
                  });
                }
              } else {
                const detail = source.canister.identity.from;
                valueItems.push({
                  name: exportedName,
                  type: {
                    type: 'identity'
                  },
                  detail,
                  extra: {
                    constant: false
                  } // not sure
                });
              }
            }
          }
      }

      break;
  }
  values.innerValues.push(...findInnerValueItemsByExported(source, {
    propValues: values.propValues
  })); // insert exported inner value if found
  valueItems.push(...findOuterValueItemsByExported(source, {
    propValues: values.propValues
  })); // insert exported outer value if found
};

// find exported outer value from argument constraint
const findOuterValueItemsByArgumentConstraint = (arg, values, valueItems) => {
  switch (arg.constraint.type) {
    case 'force':
      findInnerValueItemsByDataSource(arg.constraint.source, {
        propValues: values.propValues
      }, values.innerValues);
      findOuterValueItemsByDataSource(arg.constraint.source, values, valueItems);
      break;
    case 'blob':
      if (arg.constraint.length) {
        findInnerValueItemsByDataSource(arg.constraint.length, {
          propValues: values.propValues
        }, values.innerValues);
        findOuterValueItemsByDataSource(arg.constraint.length, values, valueItems);
      }

      // only constant
      if (arg.constraint.constant > 0 && arg.constraint.subitems) {
        for (let i = 0; i < arg.constraint.constant; i++) {
          const constraint = arg.constraint.subitems[i]?.constraint;
          if (constraint !== undefined) {
            findInnerValueItemsByArgumentConstraint(constraint, {
              propValues: values.propValues
            }, values.innerValues);
            findOuterValueItemsByArgumentConstraint(constraint, values, valueItems);
          }
        }
      }
      break;
    case 'vec':
      if (arg.constraint.length) {
        findInnerValueItemsByDataSource(arg.constraint.length, {
          propValues: values.propValues
        }, values.innerValues);
        findOuterValueItemsByDataSource(arg.constraint.length, values, valueItems);
      }

      // only constant
      if (arg.constraint.constant > 0 && arg.constraint.subitems) {
        for (let i = 0; i < arg.constraint.constant; i++) {
          const constraint = arg.constraint.subitems[i]?.constraint;
          if (constraint !== undefined) {
            findInnerValueItemsByArgumentConstraint(constraint, {
              propValues: values.propValues
            }, values.innerValues);
            findOuterValueItemsByArgumentConstraint(constraint, values, valueItems);
          }
        }
      }
      break;
    case 'opt':
      if (arg.constraint.has) {
        findInnerValueItemsByDataSource(arg.constraint.has, {
          propValues: values.propValues
        }, values.innerValues);
        findOuterValueItemsByDataSource(arg.constraint.has, values, valueItems);
      }

      // only constant
      if (arg.constraint.constant === 1) {
        findInnerValueItemsByArgumentConstraint(arg.constraint.value, {
          propValues: values.propValues
        }, values.innerValues);
        findOuterValueItemsByArgumentConstraint(arg.constraint.value, values, valueItems);
      }
      break;
    case 'record':
      for (let i = 0; i < arg.constraint.subitems.length; i++) {
        findInnerValueItemsByArgumentConstraint(arg.constraint.subitems[i], {
          propValues: values.propValues
        }, values.innerValues);
        findOuterValueItemsByArgumentConstraint(arg.constraint.subitems[i], values, valueItems);
      }
      break;
    case 'variant':
      if (arg.constraint.select) {
        findInnerValueItemsByDataSource(arg.constraint.select, {
          propValues: values.propValues
        }, values.innerValues);
        findOuterValueItemsByDataSource(arg.constraint.select, values, valueItems);
      }

      // only constant
      if (arg.constraint.constant && arg.constraint.subitems) {
        for (let i = 0; i < arg.constraint.subitems.length; i++) {
          if (arg.constraint.constant === arg.type.subitems[i].key) {
            // only the chosen one
            findInnerValueItemsByArgumentConstraint(arg.constraint.subitems[i], {
              propValues: values.propValues
            }, values.innerValues);
            findOuterValueItemsByArgumentConstraint(arg.constraint.subitems[i], values, valueItems);
            break;
          }
        }
      }
      break;
    case 'tuple':
      for (let i = 0; i < arg.constraint.subitems.length; i++) {
        findInnerValueItemsByArgumentConstraint(arg.constraint.subitems[i], {
          propValues: values.propValues
        }, values.innerValues);
        findOuterValueItemsByArgumentConstraint(arg.constraint.subitems[i], values, valueItems);
      }
      break;
    case 'rec':
      findInnerValueItemsByArgumentConstraint(arg.constraint.value, {
        propValues: values.propValues
      }, values.innerValues);
      findOuterValueItemsByArgumentConstraint(arg.constraint.value, values, valueItems);
      break;
  }
};

// find exported outer value from exported data
const findOuterValueItemsByExported = (source, values) => {
  // const valueItems: ValueItem[] = [];

  if (source.exported?.target === 'outer') {
    const name = source.exported.name?.trim();
    if (name) {
      // if export to outer and has name
      let valueResult = findConstantValue(source, {
        propValues: values.propValues
      });
      const sourceType = types_source_dist_moraLightCoreTypesSource.findDataSourceType(source); // find data source type
      const child = running.findAloneType(sourceType);
      const r = {
        name,
        type: sourceType,
        extra: {
          constant: false
        } // default is dynamic
      };

      if (child.child) r.child = child.child;
      if (valueResult?.ok !== undefined) r.extra = {
        constant: true,
        runtime: valueResult
      };
      return [r];
    }
  }
  return [];
};

// light core data

// find used lights
// findUsedLights takes in a LightCore object and returns an array of all lights that are currently in use.
const findUsedLights = core => {
  const findUsedByArgumentConstraint = arg => {
    const used = [];
    switch (arg.constraint.type) {
      case 'force':
        return findUsedByDataSource(arg.constraint.source);
      case 'blob':
        if (arg.constraint.constant === 0) return [];
        if (arg.constraint.constant > 0) {
          for (let i = 0; i < arg.constraint.constant; i++) {
            const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
            used.push(...findUsedByArgumentConstraint(constraint));
          }
        } else {
          used.push(...findUsedByDataSource(arg.constraint.length));
          const length = Math.max(arg.constraint.subitems.length, arg.constraint.subitems2?.length ?? 0);
          for (let i = 0; i < length; i++) {
            const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
            used.push(...findUsedByArgumentConstraint(constraint));
          }
          used.push(...findUsedByArgumentConstraint(arg.constraint.default));
        }
        return used;
      case 'vec':
        if (arg.constraint.constant === 0) return [];
        if (arg.constraint.constant > 0) {
          for (let i = 0; i < arg.constraint.constant; i++) {
            const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
            used.push(...findUsedByArgumentConstraint(constraint));
          }
        } else {
          used.push(...findUsedByDataSource(arg.constraint.length));
          const length = Math.max(arg.constraint.subitems.length, arg.constraint.subitems2?.length ?? 0);
          for (let i = 0; i < length; i++) {
            const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
            used.push(...findUsedByArgumentConstraint(constraint));
          }
          used.push(...findUsedByArgumentConstraint(arg.constraint.default));
        }
        return used;
      case 'opt':
        if (arg.constraint.constant === 0) return [];
        if (arg.constraint.constant !== 1) {
          used.push(...findUsedByDataSource(arg.constraint.has));
        }
        used.push(...findUsedByArgumentConstraint(arg.constraint.value));
        return used;
      case 'record':
        for (const subitem of arg.constraint.subitems) {
          used.push(...findUsedByArgumentConstraint(subitem));
        }
        return used;
      case 'variant':
        if (arg.constraint.constant) {
          const key = arg.constraint.constant;
          if (arg.type.subitems.find(subitem => subitem.key === key)) {
            return findUsedByArgumentConstraint(arg.constraint.value);
          }
        }
        used.push(...findUsedByDataSource(arg.constraint.select));
        for (const subitem of arg.constraint.subitems) {
          used.push(...findUsedByArgumentConstraint(subitem));
        }
        return used;
      case 'tuple':
        for (const subitem of arg.constraint.subitems) {
          used.push(...findUsedByArgumentConstraint(subitem));
        }
        return used;
      case 'rec':
        used.push(...findUsedByArgumentConstraint(arg.constraint.value));
        return used;
    }
  };
  const findUsedByDataSource = source => {
    switch (source.source) {
      case 'outer':
        return [];
      case 'prop':
        return [];
      case 'inner':
        return [];
      case 'constant':
        return [];
      case 'input':
        return [];
      case 'canister':
        // check args
        return findUsedByArgumentConstraint(source.canister.arg);
      case 'combined':
        // check args
        return findUsedByArgumentConstraint(source.combined.arg);
      case 'light':
        return [...findUsedByArgumentConstraint(source.light.arg), source.light.info.hash];
    }
  };
  const used = [];
  for (const source of core.data) {
    const found = findUsedByDataSource(source);
    for (const hash of found) {
      if (!used.includes(hash)) {
        used.push(hash);
      }
    }
  }
  return used;
};
const findAllCanisterInfo = core => {
  const findUsedByArgumentConstraint = arg => {
    const used = [];
    switch (arg.constraint.type) {
      case 'force':
        return findUsedByDataSource(arg.constraint.source);
      case 'blob':
        if (arg.constraint.constant === 0) return [];
        if (arg.constraint.constant > 0) {
          for (let i = 0; i < arg.constraint.constant; i++) {
            const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
            used.push(...findUsedByArgumentConstraint(constraint));
          }
        } else {
          used.push(...findUsedByDataSource(arg.constraint.length));
          const length = Math.max(arg.constraint.subitems.length, arg.constraint.subitems2?.length ?? 0);
          for (let i = 0; i < length; i++) {
            const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
            used.push(...findUsedByArgumentConstraint(constraint));
          }
          used.push(...findUsedByArgumentConstraint(arg.constraint.default));
        }
        return used;
      case 'vec':
        if (arg.constraint.constant === 0) return [];
        if (arg.constraint.constant > 0) {
          for (let i = 0; i < arg.constraint.constant; i++) {
            const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
            used.push(...findUsedByArgumentConstraint(constraint));
          }
        } else {
          used.push(...findUsedByDataSource(arg.constraint.length));
          const length = Math.max(arg.constraint.subitems.length, arg.constraint.subitems2?.length ?? 0);
          for (let i = 0; i < length; i++) {
            const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
            used.push(...findUsedByArgumentConstraint(constraint));
          }
          used.push(...findUsedByArgumentConstraint(arg.constraint.default));
        }
        return used;
      case 'opt':
        if (arg.constraint.constant === 0) return [];
        if (arg.constraint.constant !== 1) {
          used.push(...findUsedByDataSource(arg.constraint.has));
        }
        used.push(...findUsedByArgumentConstraint(arg.constraint.value));
        return used;
      case 'record':
        for (const subitem of arg.constraint.subitems) {
          used.push(...findUsedByArgumentConstraint(subitem));
        }
        return used;
      case 'variant':
        if (arg.constraint.constant) {
          const key = arg.constraint.constant;
          if (arg.type.subitems.find(subitem => subitem.key === key)) {
            return findUsedByArgumentConstraint(arg.constraint.value);
          }
        }
        used.push(...findUsedByDataSource(arg.constraint.select));
        for (const subitem of arg.constraint.subitems) {
          used.push(...findUsedByArgumentConstraint(subitem));
        }
        return used;
      case 'tuple':
        for (const subitem of arg.constraint.subitems) {
          used.push(...findUsedByArgumentConstraint(subitem));
        }
        return used;
      case 'rec':
        used.push(...findUsedByArgumentConstraint(arg.constraint.value));
        return used;
    }
  };
  const findUsedByDataSource = source => {
    switch (source.source) {
      case 'outer':
        return [];
      case 'prop':
        return [];
      case 'inner':
        return [];
      case 'constant':
        return [];
      case 'input':
        return [];
      case 'canister':
        // check args
        return [...findUsedByArgumentConstraint(source.canister.arg), {
          canister_id: source.canister.canister_id.fixed ? source.canister.canister_id.value : '',
          info: source.canister.info
        }];
      case 'combined':
        // check args
        return [];
      case 'light':
        return findUsedByArgumentConstraint(source.light.arg);
    }
  };
  const list = [];
  for (const source of core.data) {
    const found = findUsedByDataSource(source);
    list.push(...found);
  }
  return list;
};

// try to find constant value from data source
const findConstantValue = (source, values) => {
  let value = undefined;
  switch (source.source) {
    case 'light':
      if (!source.transform && source.light.info.extra.constant && source.light.info.extra.runtime !== undefined) {
        value = source.light.info.extra.runtime;
      }
      break;
    case 'combined':
      break;
    case 'canister':
      break;
    case 'input':
      break;
    case 'constant':
      if (!source.transform) {
        value = {
          ok: source.constant.value
        };
      }
      break;
    case 'inner':
      if (!source.transform && source.inner.extra.constant && source.inner.extra.runtime !== undefined) {
        value = source.inner.extra.runtime;
      }
      break;
    case 'prop':
      if (!source.transform) {
        const prop = values.propValues.find(prop => prop.name === source.prop.name);
        if (prop !== undefined) {
          if (isCandidType(prop) && running.isSameCandidType(prop.type, source.prop.result) && prop.extra.constant) {
            value = prop.extra.runtime;
          }
        }
      }
      break;
    case 'outer':
      if (!source.transform && source.outer.extra?.constant && source.outer.extra.runtime !== undefined) {
        value = source.outer.extra.runtime;
      }
      break;
  }
  return clones.deepClone(value);
};

// find light's type and constant value if exist. note: did not care about transform of source
const parseLightCandidType = (data, values) => {
  let subitems = [];
  let constant = true;
  let error = undefined;
  const runtime = [];
  for (let i = 0; i < data.length; i++) {
    const source = data[i];
    subitems[i] = types_source_dist_moraLightCoreTypesSource.findDataSourceType(source); // find data source type
    // check constant or not
    if (constant) {
      const valueResult = findConstantValue(source, values);
      if (valueResult !== undefined) {
        if (valueResult.err !== undefined) error = valueResult;
        if (valueResult.ok !== undefined) {
          runtime.push(valueResult.ok);
          continue;
        }
      }
      constant = false; // dynamic if any value is dynamic
    }
  }

  const ok = {
    result: running.parseTuple(subitems)
  };
  if (constant) ok.runtime = {
    ok: runtime
  };else if (error !== undefined) ok.runtime = error; // error message

  return ok;
};
const getLightStatusInfo = light => {
  if (light === undefined) {
    return {
      has: false,
      hasDataComponent: false,
      hasTriggerComponent: false,
      hasShowComponent: false
    };
  }
  const hasDataComponent = (() => {
    const data = light.data;
    const checkArgumentConstraint = arg => {
      switch (arg.constraint.type) {
        case 'force':
          return checkDataSource(arg.constraint.source);
        case 'blob':
          if (arg.constraint.constant === 0) return false;
          if (arg.constraint.constant > 0) {
            for (let i = 0; i < arg.constraint.constant; i++) {
              const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
              if (checkArgumentConstraint(constraint)) return true;
            }
            return false;
          } else {
            if (checkDataSource(arg.constraint.length)) return true;
            const length = Math.max(arg.constraint.subitems.length, arg.constraint.subitems2?.length ?? 0);
            for (let i = 0; i < length; i++) {
              const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
              if (checkArgumentConstraint(constraint)) return true;
            }
            if (checkArgumentConstraint(arg.constraint.default)) return true;
          }
          return false;
        case 'vec':
          if (arg.constraint.constant === 0) return false;
          if (arg.constraint.constant > 0) {
            for (let i = 0; i < arg.constraint.constant; i++) {
              const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
              if (checkArgumentConstraint(constraint)) return true;
            }
            return false;
          } else {
            if (checkDataSource(arg.constraint.length)) return true;
            const length = Math.max(arg.constraint.subitems.length, arg.constraint.subitems2?.length ?? 0);
            for (let i = 0; i < length; i++) {
              const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
              if (checkArgumentConstraint(constraint)) return true;
            }
            if (checkArgumentConstraint(arg.constraint.default)) return true;
          }
          return false;
        case 'opt':
          if (arg.constraint.constant === 0) return false;
          if (arg.constraint.constant === 1) {
            return checkArgumentConstraint(arg.constraint.value);
          }
          if (checkDataSource(arg.constraint.has)) return true;
          if (checkArgumentConstraint(arg.constraint.value)) return true;
          return false;
        case 'record':
          for (let i = 0; i < arg.constraint.subitems.length; i++) {
            if (checkArgumentConstraint(arg.constraint.subitems[i])) return true;
          }
          return false;
        case 'variant':
          if (arg.constraint.constant) {
            const key = arg.constraint.constant;
            if (arg.type.subitems.find(subitem => subitem.key === key)) {
              return checkArgumentConstraint(arg.constraint.value);
            }
          }
          if (checkDataSource(arg.constraint.select)) return true;
          for (let i = 0; i < arg.constraint.subitems.length; i++) {
            if (checkArgumentConstraint(arg.constraint.subitems[i])) return true;
          }
          return false;
        case 'tuple':
          for (let i = 0; i < arg.constraint.subitems.length; i++) {
            if (checkArgumentConstraint(arg.constraint.subitems[i])) return true;
          }
          return false;
        case 'rec':
          if (checkArgumentConstraint(arg.constraint.value)) return true;
          return false;
      }
    };
    const checkDataSource = source => {
      switch (source.source) {
        case 'light':
          return checkArgumentConstraint(source.light.arg);
        case 'combined':
          return false;
        case 'canister':
          if (checkArgumentConstraint(source.canister.arg)) return true;
          switch (source.canister.identity.from) {
            case 'anonymous':
              return false;
            case 'host':
              return true;
            case 'login':
              return true;
            case 'host-login':
              return true;
            case 'inner':
              return true;
            case 'outer':
              return true;
          }
        case 'input':
          return true;
        case 'constant':
          return false;
        case 'inner':
          return false;
        case 'prop':
          return false;
        case 'outer':
          return false;
      }
    };
    for (let i = 0; i < data.length; i++) if (checkDataSource(data[i])) return true;
    return false;
  })();
  const hasTriggerComponent = (() => {
    const trigger = light.trigger;
    if (!trigger) return true;
    switch (trigger.type) {
      case 'loading':
        return true;
      case 'button':
        return true;
      case 'clock':
        return true;
    }
    return false;
  })();
  const hasShowComponent = (() => !!light.transmits.filter(t => t.transmit === 'show').length)();

  // console.error("lightStatusInfo", light, {
  //     has: hasDataComponent || hasTriggerComponent || hasShowComponent,
  //     hasDataComponent,
  //     hasTriggerComponent,
  //     hasShowComponent,
  // });

  return {
    has: hasDataComponent || hasTriggerComponent || hasShowComponent,
    hasDataComponent,
    hasTriggerComponent,
    hasShowComponent
  };
};
const findPropDataSources = data => {
  const sources = [];
  const findPropsByDataSource = source => {
    const sources = [];
    switch (source.source) {
      case 'light':
        sources.push(...findPropsByArgumentConstraint(source.light.arg));
        break;
      case 'combined':
        sources.push(...findPropsByArgumentConstraint(source.combined.arg));
        break;
      case 'canister':
        if (!source.canister.canister_id.fixed && source.canister.canister_id.source) sources.push(...findPropsByDataSource(source.canister.canister_id.source));
        sources.push(...findPropsByArgumentConstraint(source.canister.arg));
        break;
      case 'input':
        break;
      case 'constant':
        break;
      case 'inner':
        break;
      case 'prop':
        sources.push(clones.deepClone(source));
        break;
    }
    return sources;
  };
  const findPropsByArgumentConstraint = arg => {
    const sources = [];
    switch (arg.constraint.type) {
      case 'force':
        sources.push(...findPropsByDataSource(arg.constraint.source));
        break;
      case 'blob':
        if (arg.constraint.constant === 0) break;
        if (arg.constraint.constant > 0) {
          for (let i = 0; i < arg.constraint.constant; i++) {
            const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
            sources.push(...findPropsByArgumentConstraint(constraint));
          }
        } else {
          if (findPropsByDataSource(arg.constraint.length)) return sources;
          const length = Math.max(arg.constraint.subitems.length, arg.constraint.subitems2?.length ?? 0);
          for (let i = 0; i < length; i++) {
            const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
            sources.push(...findPropsByArgumentConstraint(constraint));
          }
        }
        break;
      case 'vec':
        if (arg.constraint.constant === 0) break;
        if (arg.constraint.constant > 0) {
          for (let i = 0; i < arg.constraint.constant; i++) {
            const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
            sources.push(...findPropsByArgumentConstraint(constraint));
          }
        } else {
          if (findPropsByDataSource(arg.constraint.length)) return sources;
          const length = Math.max(arg.constraint.subitems.length, arg.constraint.subitems2?.length ?? 0);
          for (let i = 0; i < length; i++) {
            const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
            sources.push(...findPropsByArgumentConstraint(constraint));
          }
        }
        break;
      case 'opt':
        if (arg.constraint.constant === 0) break;
        if (arg.constraint.constant !== 1) {
          sources.push(...findPropsByDataSource(arg.constraint.has));
        }
        sources.push(...findPropsByArgumentConstraint(arg.constraint.value));
        break;
      case 'record':
        for (const subitem of arg.constraint.subitems) {
          sources.push(...findPropsByArgumentConstraint(subitem));
        }
        break;
      case 'variant':
        if (arg.constraint.constant) {
          const key = arg.constraint.constant;
          if (arg.type.subitems.find(subitem => subitem.key === key)) {
            return findPropsByArgumentConstraint(arg.constraint.value);
          }
        }
        sources.push(...findPropsByDataSource(arg.constraint.select));
        for (const subitem of arg.constraint.subitems) {
          sources.push(...findPropsByArgumentConstraint(subitem));
        }
        break;
      case 'tuple':
        for (const subitem of arg.constraint.subitems) {
          sources.push(...findPropsByArgumentConstraint(subitem));
        }
        break;
      case 'rec':
        sources.push(...findPropsByArgumentConstraint(arg.constraint.value));
        break;
    }
    return sources;
  };
  for (const source of data) {
    sources.push(...findPropsByDataSource(source));
  }

  // check name and type
  const props = {};
  const sources2 = [];
  for (const source of sources) {
    if (!source.prop.name) throw new Error('prop name is required');
    const name = source.prop.name;
    const type = props[name];
    if (!type) {
      props[name] = source.prop.result;
      sources2.push(source);
    } else if (!running.isSameCandidType(type, source.prop.result)) {
      throw new Error('same prop name require same type');
    }
  }
  return sources2;
};
const findCanisterDataSources = data => {
  const sources = [];
  const findCanisterByDataSource = source => {
    const sources = [];
    switch (source.source) {
      case 'light':
        sources.push(...findCanisterByArgumentConstraint(source.light.arg));
        break;
      case 'combined':
        sources.push(...findCanisterByArgumentConstraint(source.combined.arg));
        break;
      case 'canister':
        if (!source.canister.canister_id.fixed && source.canister.canister_id.source) sources.push(...findCanisterByDataSource(source.canister.canister_id.source));
        sources.push(...findCanisterByArgumentConstraint(source.canister.arg));
        sources.push(clones.deepClone(source));
        break;
    }
    return sources;
  };
  const findCanisterByArgumentConstraint = arg => {
    const sources = [];
    switch (arg.constraint.type) {
      case 'force':
        sources.push(...findCanisterByDataSource(arg.constraint.source));
        break;
      case 'blob':
        if (arg.constraint.constant === 0) break;
        if (arg.constraint.constant > 0) {
          for (let i = 0; i < arg.constraint.constant; i++) {
            const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
            sources.push(...findCanisterByArgumentConstraint(constraint));
          }
        } else {
          if (findCanisterByDataSource(arg.constraint.length)) return sources;
          const length = Math.max(arg.constraint.subitems.length, arg.constraint.subitems2?.length ?? 0);
          for (let i = 0; i < length; i++) {
            const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
            sources.push(...findCanisterByArgumentConstraint(constraint));
          }
        }
        break;
      case 'vec':
        if (arg.constraint.constant === 0) break;
        if (arg.constraint.constant > 0) {
          for (let i = 0; i < arg.constraint.constant; i++) {
            const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
            sources.push(...findCanisterByArgumentConstraint(constraint));
          }
        } else {
          if (findCanisterByDataSource(arg.constraint.length)) return sources;
          const length = Math.max(arg.constraint.subitems.length, arg.constraint.subitems2?.length ?? 0);
          for (let i = 0; i < length; i++) {
            const constraint = types_source_dist_moraLightCoreTypesSource.findVecArgumentConstraintByIndex(arg, i);
            sources.push(...findCanisterByArgumentConstraint(constraint));
          }
        }
        break;
      case 'opt':
        if (arg.constraint.constant === 0) break;
        if (arg.constraint.constant !== 1) {
          sources.push(...findCanisterByDataSource(arg.constraint.has));
        }
        sources.push(...findCanisterByArgumentConstraint(arg.constraint.value));
        break;
      case 'record':
        for (const subitem of arg.constraint.subitems) {
          sources.push(...findCanisterByArgumentConstraint(subitem));
        }
        break;
      case 'variant':
        if (arg.constraint.constant) {
          const key = arg.constraint.constant;
          if (arg.type.subitems.find(subitem => subitem.key === key)) {
            return findCanisterByArgumentConstraint(arg.constraint.value);
          }
        }
        sources.push(...findCanisterByDataSource(arg.constraint.select));
        for (const subitem of arg.constraint.subitems) {
          sources.push(...findCanisterByArgumentConstraint(subitem));
        }
        break;
      case 'tuple':
        for (const subitem of arg.constraint.subitems) {
          sources.push(...findCanisterByArgumentConstraint(subitem));
        }
        break;
      case 'rec':
        sources.push(...findCanisterByArgumentConstraint(arg.constraint.value));
        break;
    }
    return sources;
  };
  for (const source of data) {
    sources.push(...findCanisterByDataSource(source));
  }
  return sources;
};

exports.findAllCanisterInfo = findAllCanisterInfo;
exports.findCanisterDataSources = findCanisterDataSources;
exports.findConstantValue = findConstantValue;
exports.findInnerValueItemsByArgumentConstraint = findInnerValueItemsByArgumentConstraint;
exports.findInnerValueItemsByDataSource = findInnerValueItemsByDataSource;
exports.findInnerValueItemsByExported = findInnerValueItemsByExported;
exports.findInnerValueItemsByLightCore = findInnerValueItemsByLightCore;
exports.findOuterValueItemsByArgumentConstraint = findOuterValueItemsByArgumentConstraint;
exports.findOuterValueItemsByDataSource = findOuterValueItemsByDataSource;
exports.findOuterValueItemsByExported = findOuterValueItemsByExported;
exports.findOuterValueItemsByLightCore = findOuterValueItemsByLightCore;
exports.findPropDataSources = findPropDataSources;
exports.findUsedLights = findUsedLights;
exports.getLightStatusInfo = getLightStatusInfo;
exports.getValueItem = getValueItem;
exports.isCandidType = isCandidType;
exports.isCustomIdentityType = isCustomIdentityType;
exports.isCustomType = isCustomType;
exports.isSameValueItemType = isSameValueItemType;
exports.parseLightCandidType = parseLightCandidType;