@xylabs/typeof/dist/neutral/index.mjs

Base functionality used throughout XY Labs TypeScript/JavaScript libraries

// src/typeOf.ts
var typeOf = (item) => {
  return Array.isArray(item) ? "array" : typeof item;
};

// src/ifDefined.ts
var ifDefined = (value, func) => {
  switch (typeOf(value)) {
    case "undefined":
    case "null": {
      break;
    }
    default: {
      func(value);
      return value;
    }
  }
};

// src/ifTypeOf.ts
var ifTypeOf = (typeName, value, trueFunc, isFunc) => {
  switch (typeOf(value)) {
    case typeName: {
      return !isFunc || isFunc(value) ? trueFunc(value) : void 0;
    }
  }
};

// src/isType.ts
var isType = (value, expectedType) => {
  const typeofValue = typeof value;
  switch (expectedType) {
    case "array": {
      return Array.isArray(value);
    }
    case "null": {
      return value === null;
    }
    case "undefined": {
      return value === void 0;
    }
    case "object": {
      if (value === null) {
        return false;
      }
      return typeofValue === "object" && !Array.isArray(value);
    }
    default: {
      return typeofValue === expectedType;
    }
  }
};

// src/Typed.ts
var isTypedKey = (value) => {
  switch (typeof value) {
    case "string":
    case "bigint":
    case "number":
    case "symbol": {
      return true;
    }
    default: {
      return false;
    }
  }
};
var isTypedValue = (value) => {
  switch (typeof value) {
    case "string":
    case "number":
    case "boolean": {
      return true;
    }
    default: {
      return value === null || isTypedObject(value) || isTypedArray(value);
    }
  }
};
var isTypedArray = (value) => {
  return Array.isArray(value) && !value.some((item) => !isTypedValue(item));
};
var isValidTypedFieldPair = (pair) => {
  const [key, value] = pair;
  return isTypedKey(key) && isTypedValue(value);
};
var isTypedObject = (value) => {
  return isType(value, "object") && !Object.entries(value).some((item) => !isValidTypedFieldPair(item));
};

// src/validateType.ts
var validateType = (typeName, value, optional = false) => {
  switch (typeOf(value)) {
    case typeName: {
      return [value, []];
    }
    default: {
      if (optional && typeOf(value) === "undefined") {
        return [value, []];
      }
      return [void 0, [new Error(`value type is not '${typeName}:${typeof value}'`)]];
    }
  }
};
export {
  ifDefined,
  ifTypeOf,
  isType,
  isTypedArray,
  isTypedKey,
  isTypedObject,
  isTypedValue,
  isValidTypedFieldPair,
  typeOf,
  validateType
};
//# sourceMappingURL=index.mjs.map