@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/is.ts
function isUndefined(value) {
  return value === void 0;
}
function isDefined(value) {
  return !isUndefined(value);
}
function isNull(value) {
  return value === null;
}
function isDefinedNotNull(value) {
  return !isUndefined(value) && !isNull(value);
}
function isUndefinedOrNull(value) {
  return isUndefined(value) || isNull(value);
}
function isBigInt(value) {
  return typeof value === "bigint";
}
function isString(value) {
  return typeof value === "string";
}
function isNumber(value) {
  return typeof value === "number";
}
function isObject(value) {
  return typeof value === "object" && value !== null && !Array.isArray(value);
}
function isArray(value) {
  return Array.isArray(value);
}
function isFunction(value) {
  return typeof value === "function";
}
function isSymbol(value) {
  return typeof value === "symbol";
}
function isEmptyObject(value) {
  return isObject(value) && Object.keys(value).length === 0;
}
function isEmptyString(value) {
  return isString(value) && value.length === 0;
}
function isEmptyArray(value) {
  return isArray(value) && value.length === 0;
}
function isPopulatedArray(value) {
  return isArray(value) && value.length > 0;
}
function isEmpty(value) {
  return isEmptyString(value) || isEmptyArray(value) || isEmptyObject(value);
}
function isFalsy(value) {
  return !value;
}
function isTruthy(value) {
  return !!value;
}
function isBoolean(value) {
  return typeof value === "boolean";
}
function isDateString(value) {
  return isString(value) && !Number.isNaN(Date.parse(value));
}
function isDate(value) {
  return value instanceof Date;
}
function isRegExp(value) {
  return value instanceof RegExp;
}
function isError(value) {
  return value instanceof Error;
}
function isPromise(value) {
  return value instanceof Promise;
}
function isPromiseLike(value) {
  return typeof value === "object" && value !== null && typeof value.then === "function";
}
function isMap(value) {
  return value instanceof Map;
}
function isArrayBufferView(value) {
  return ArrayBuffer.isView(value);
}
function isSet(value) {
  return value instanceof Set;
}
function isWeakMap(value) {
  return value instanceof WeakMap;
}
function isWeakSet(value) {
  return value instanceof WeakSet;
}
function isArrayBuffer(value) {
  return value instanceof ArrayBuffer;
}
function isDataView(value) {
  return value instanceof DataView;
}
function isBlob(value) {
  return typeof Blob !== "undefined" && value instanceof Blob;
}
function isFile(value) {
  return typeof File !== "undefined" && value instanceof File;
}

// 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,
  isArray,
  isArrayBuffer,
  isArrayBufferView,
  isBigInt,
  isBlob,
  isBoolean,
  isDataView,
  isDate,
  isDateString,
  isDefined,
  isDefinedNotNull,
  isEmpty,
  isEmptyArray,
  isEmptyObject,
  isEmptyString,
  isError,
  isFalsy,
  isFile,
  isFunction,
  isMap,
  isNull,
  isNumber,
  isObject,
  isPopulatedArray,
  isPromise,
  isPromiseLike,
  isRegExp,
  isSet,
  isString,
  isSymbol,
  isTruthy,
  isType,
  isTypedArray,
  isTypedKey,
  isTypedObject,
  isTypedValue,
  isUndefined,
  isUndefinedOrNull,
  isValidTypedFieldPair,
  isWeakMap,
  isWeakSet,
  typeOf,
  validateType
};
//# sourceMappingURL=index.mjs.map