@tokens-studio/tokenscript-schemas 0.0.11 → 0.0.13

package/src/utils/type.ts

@@ -0,0 +1,194 @@
+// Optional --------------------------------------------------------------------
+
+export const isSome = <T>(v: T | null | undefined): v is T => {
+  return v != null;
+};
+
+export const isNone = (v: unknown): v is null | undefined => {
+  return v == null;
+};
+
+// Primitive type guards -------------------------------------------------------
+
+export const isNull = (v: unknown): v is null => {
+  return v === null;
+};
+
+export const isUndefined = (v: unknown): v is undefined => {
+  return v === undefined;
+};
+
+export const isObject = (v: unknown): v is Record<string, unknown> => {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+};
+
+export const isString = (v: unknown): v is string => {
+  return typeof v === "string";
+};
+
+export const isNumber = (v: unknown): v is number => {
+  return typeof v === "number" && !Number.isNaN(v);
+};
+
+export const isBoolean = (v: unknown): v is boolean => {
+  return typeof v === "boolean";
+};
+
+export const isArray = <T = unknown>(v: unknown): v is T[] => {
+  return Array.isArray(v);
+};
+
+export const isFunction = (v: unknown): v is (...args: unknown[]) => unknown => {
+  return typeof v === "function";
+};
+
+export const isDate = (v: unknown): v is Date => {
+  return v instanceof Date && !Number.isNaN(v.getTime());
+};
+
+// Object ----------------------------------------------------------------------
+
+export const isMap = (v: unknown): v is Map<unknown, unknown> => v instanceof Map;
+
+export const isPlainObject = (v: unknown): v is Record<string, unknown> => {
+  if (!isObject(v)) return false;
+
+  // Objects created by the Object constructor or with null prototype
+  const proto = Object.getPrototypeOf(v);
+  return proto === Object.prototype || proto === null;
+};
+
+export const hasProperty = <K extends string>(obj: unknown, key: K): obj is Record<K, unknown> => {
+  return isObject(obj) && key in obj;
+};
+
+export const getKeyAlt = <K extends string, T>(
+  keys: readonly K[],
+  record: Partial<Record<K, T>>,
+): T | undefined => {
+  for (const key of keys) {
+    if (key in record) {
+      return record[key];
+    }
+  }
+  return undefined;
+};
+
+export const isObjectWithKey = <K extends string>(
+  value: unknown,
+  key: K,
+): value is Record<K, unknown> => {
+  return isObject(value) && key in value;
+};
+
+export const isNonEmptyObject = (v: unknown): boolean => {
+  return isObject(v) && Object.keys(v).length > 0;
+};
+
+export const isSingleEntryObject = (v: unknown): boolean => {
+  return isObject(v) && Object.keys(v).length === 1;
+};
+
+// Array -----------------------------------------------------------------------
+
+export const isNonEmptyArray = <T>(v: unknown): v is [T, ...T[]] => {
+  return isArray(v) && v.length > 0;
+};
+
+export const ensureArray = <T>(v: T | T[] | null | undefined): T[] => {
+  if (isNone(v)) return [];
+  if (isArray<T>(v)) return v;
+  return [v];
+};
+
+export const isOutOfBounds = <T>(value: unknown, index: number): boolean => {
+  if (!isArray<T>(value)) return true;
+  return index < 0 || index >= value.length;
+};
+
+export const isOutOfBoundsInclusive = <T>(value: unknown, index: number): boolean => {
+  if (!isArray<T>(value)) return true;
+  return index < 0 || index > value.length;
+};
+
+export const isEmpty = (v: unknown): boolean => {
+  if (isNone(v)) return true;
+  if (isString(v) || isArray(v)) return v.length === 0;
+  if (isObject(v)) return Object.keys(v).length === 0;
+  return false;
+};
+
+// Number parsing --------------------------------------------------------------
+
+export const safeParseInt = (v: unknown): number | null => {
+  if (isNumber(v)) return Math.floor(v);
+  if (isString(v)) {
+    const parsed = parseInt(v, 10);
+    return Number.isNaN(parsed) ? null : parsed;
+  }
+  return null;
+};
+
+export const safeParseFloat = (v: unknown): number | null => {
+  if (isNumber(v)) return v;
+  if (isString(v)) {
+    const parsed = parseFloat(v);
+    return Number.isNaN(parsed) ? null : parsed;
+  }
+  return null;
+};
+
+// Type Assertion Helpers ------------------------------------------------------
+
+export const assertIsSome = <T>(v: T | null | undefined, message?: string): T => {
+  if (isNone(v)) {
+    throw new Error(message || "Expected value to be defined");
+  }
+  return v;
+};
+
+export const assertIsType = <T>(v: unknown, guard: (v: unknown) => v is T, message?: string): T => {
+  if (!guard(v)) {
+    throw new Error(message || "Type assertion failed");
+  }
+  return v;
+};
+
+export const optional = <T, R>(value: T | null | undefined, fn: (v: T) => R): R | undefined => {
+  return isSome(value) ? fn(value) : undefined;
+};
+
+export const when = <A, B>(a: A, b: B): B | undefined => {
+  return a !== undefined && a !== null && a !== false ? b : undefined;
+};
+
+export const withDefault = <T>(v: T | null | undefined, defaultValue: T): T => {
+  return isSome(v) ? v : defaultValue;
+};
+
+export const isEqual = (a: unknown, b: unknown): boolean => {
+  if (a === b) return true;
+
+  if (isNone(a) || isNone(b)) return a === b;
+
+  if (isArray(a) && isArray(b)) {
+    if (a.length !== b.length) return false;
+    return a.every((item, index) => isEqual(item, b[index]));
+  }
+
+  if (isObject(a) && isObject(b)) {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+
+    if (keysA.length !== keysB.length) return false;
+
+    return keysA.every((key) => keysB.includes(key) && isEqual(a[key], b[key]));
+  }
+
+  return false;
+};
+
+// Conversion ------------------------------------------------------------------
+
+export const nullToUndefined = <T>(v: T | null | undefined): T | undefined =>
+  isNull(v) ? undefined : v;