contexify/dist/utils/value-promise.js

A TypeScript library providing a powerful dependency injection container with context-based IoC capabilities, inspired by LoopBack's Context system.

var __defProp = Object.defineProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
import { generateUUID } from "./unique-id.js";
function isPromiseLike(value) {
  if (!value) return false;
  if (typeof value !== "object" && typeof value !== "function") return false;
  return typeof value.then === "function";
}
__name(isPromiseLike, "isPromiseLike");
function getDeepProperty(value, path) {
  let result = value;
  const props = path.split(".").filter(Boolean);
  for (const p of props) {
    if (result == null) {
      return void 0;
    }
    result = result[p];
  }
  return result;
}
__name(getDeepProperty, "getDeepProperty");
function resolveMap(map, resolver) {
  const result = {};
  let asyncResolvers;
  const setter = /* @__PURE__ */ __name((key) => (val) => {
    if (val !== void 0) {
      result[key] = val;
    }
  }, "setter");
  for (const key in map) {
    const valueOrPromise = resolver(map[key], key, map);
    if (isPromiseLike(valueOrPromise)) {
      if (!asyncResolvers) asyncResolvers = [];
      asyncResolvers.push(valueOrPromise.then(setter(key)));
    } else {
      if (valueOrPromise !== void 0) {
        result[key] = valueOrPromise;
      }
    }
  }
  if (asyncResolvers) {
    return Promise.all(asyncResolvers).then(() => result);
  }
  return result;
}
__name(resolveMap, "resolveMap");
function resolveList(list, resolver) {
  const result = new Array(list.length);
  let asyncResolvers;
  const setter = /* @__PURE__ */ __name((index) => (val) => {
    result[index] = val;
  }, "setter");
  for (let ix = 0; ix < list.length; ix++) {
    const valueOrPromise = resolver(list[ix], ix, list);
    if (isPromiseLike(valueOrPromise)) {
      if (!asyncResolvers) asyncResolvers = [];
      asyncResolvers.push(valueOrPromise.then(setter(ix)));
    } else {
      result[ix] = valueOrPromise;
    }
  }
  if (asyncResolvers) {
    return Promise.all(asyncResolvers).then(() => result);
  }
  return result;
}
__name(resolveList, "resolveList");
function tryWithFinally(action, finalAction) {
  return tryCatchFinally(action, void 0, finalAction);
}
__name(tryWithFinally, "tryWithFinally");
function tryCatchFinally(action, errorAction = (err) => {
  throw err;
}, finalAction = () => {
}) {
  let result;
  try {
    result = action();
  } catch (err) {
    result = reject(err);
  }
  if (isPromiseLike(result)) {
    return result.then(resolve, reject);
  }
  return resolve(result);
  function resolve(value) {
    try {
      return value;
    } finally {
      finalAction();
    }
  }
  __name(resolve, "resolve");
  function reject(err) {
    try {
      return errorAction(err);
    } finally {
      finalAction();
    }
  }
  __name(reject, "reject");
}
__name(tryCatchFinally, "tryCatchFinally");
function resolveUntil(source, resolver, evaluator) {
  while (true) {
    const next = source.next();
    if (next.done) return void 0;
    const sourceVal = next.value;
    const valueOrPromise = resolver(sourceVal);
    if (isPromiseLike(valueOrPromise)) {
      return valueOrPromise.then((v) => {
        if (evaluator(sourceVal, v)) {
          return v;
        }
        return resolveUntil(source, resolver, evaluator);
      });
    }
    if (evaluator(sourceVal, valueOrPromise)) {
      return valueOrPromise;
    }
  }
}
__name(resolveUntil, "resolveUntil");
function transformValueOrPromise(valueOrPromise, transformer) {
  if (isPromiseLike(valueOrPromise)) {
    return valueOrPromise.then(transformer);
  }
  return transformer(valueOrPromise);
}
__name(transformValueOrPromise, "transformValueOrPromise");
function uuid() {
  return generateUUID();
}
__name(uuid, "uuid");
const UUID_PATTERN = /[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}/i;
export {
  UUID_PATTERN,
  getDeepProperty,
  isPromiseLike,
  resolveList,
  resolveMap,
  resolveUntil,
  transformValueOrPromise,
  tryCatchFinally,
  tryWithFinally,
  uuid
};
//# sourceMappingURL=value-promise.js.map