@goodscript/core 0.13.0

package/src/map-tools-gs.ts

@@ -0,0 +1,96 @@
+/**
+ * Map utilities with dual error handling pattern.
+ */
+export class MapTools {
+  /**
+   * Get value from map, or return default if key doesn't exist.
+   */
+  static getOrDefault<K, V>(map: Map<K, V>, key: K, defaultValue: V): V {
+    const value = map.get(key);
+    return value !== undefined ? value : defaultValue;
+  }
+
+  /**
+   * Get value from map. Returns null if key doesn't exist.
+   */
+  static tryGet<K, V>(map: Map<K, V>, key: K): V | null {
+    const value = map.get(key);
+    return value !== undefined ? value : null;
+  }
+
+  /**
+   * Get value from map. Throws if key doesn't exist.
+   */
+  static get<K, V>(map: Map<K, V>, key: K): V {
+    const value = MapTools.tryGet(map, key);
+    if (value === null) {
+      throw new Error(`Key not found in map: ${String(key)}`);
+    }
+    return value;
+  }
+
+  /**
+   * Get all keys as array.
+   */
+  static keys<K, V>(map: Map<K, V>): Array<K> {
+    return Array.from(map.keys());
+  }
+
+  /**
+   * Get all values as array.
+   */
+  static values<K, V>(map: Map<K, V>): Array<V> {
+    return Array.from(map.values());
+  }
+
+  /**
+   * Get all entries as array of tuples.
+   */
+  static entries<K, V>(map: Map<K, V>): Array<[K, V]> {
+    return Array.from(map.entries());
+  }
+
+  /**
+   * Create new map from array of tuples.
+   */
+  static fromEntries<K, V>(entries: Array<[K, V]>): Map<K, V> {
+    return new Map(entries);
+  }
+
+  /**
+   * Map over map values, returning new map with same keys.
+   */
+  static mapValues<K, V, U>(map: Map<K, V>, fn: (value: V, key: K) => U): Map<K, U> {
+    const result = new Map<K, U>();
+    for (const [key, value] of map.entries()) {
+      result.set(key, fn(value, key));
+    }
+    return result;
+  }
+
+  /**
+   * Filter map entries by predicate.
+   */
+  static filter<K, V>(map: Map<K, V>, predicate: (value: V, key: K) => boolean): Map<K, V> {
+    const result = new Map<K, V>();
+    for (const [key, value] of map.entries()) {
+      if (predicate(value, key)) {
+        result.set(key, value);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Merge multiple maps. Later maps override earlier ones.
+   */
+  static merge<K, V>(...maps: Array<Map<K, V>>): Map<K, V> {
+    const result = new Map<K, V>();
+    for (const map of maps) {
+      for (const [key, value] of map.entries()) {
+        result.set(key, value);
+      }
+    }
+    return result;
+  }
+}

package/src/set-tools-gs.ts

@@ -0,0 +1,128 @@
+/**
+ * Set utilities for set operations.
+ */
+export class SetTools {
+  /**
+   * Union of two sets (all elements from both sets).
+   */
+  static union<T>(a: Set<T>, b: Set<T>): Set<T> {
+    const result = new Set<T>(a);
+    for (const item of b) {
+      result.add(item);
+    }
+    return result;
+  }
+
+  /**
+   * Intersection of two sets (elements in both sets).
+   */
+  static intersection<T>(a: Set<T>, b: Set<T>): Set<T> {
+    const result = new Set<T>();
+    for (const item of a) {
+      if (b.has(item)) {
+        result.add(item);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Difference of two sets (elements in first set but not second).
+   */
+  static difference<T>(a: Set<T>, b: Set<T>): Set<T> {
+    const result = new Set<T>();
+    for (const item of a) {
+      if (!b.has(item)) {
+        result.add(item);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Symmetric difference (elements in either set but not both).
+   */
+  static symmetricDifference<T>(a: Set<T>, b: Set<T>): Set<T> {
+    const result = new Set<T>();
+    for (const item of a) {
+      if (!b.has(item)) {
+        result.add(item);
+      }
+    }
+    for (const item of b) {
+      if (!a.has(item)) {
+        result.add(item);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Check if first set is subset of second.
+   */
+  static isSubset<T>(a: Set<T>, b: Set<T>): boolean {
+    for (const item of a) {
+      if (!b.has(item)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Check if first set is superset of second.
+   */
+  static isSuperset<T>(a: Set<T>, b: Set<T>): boolean {
+    return SetTools.isSubset(b, a);
+  }
+
+  /**
+   * Check if sets are disjoint (no common elements).
+   */
+  static isDisjoint<T>(a: Set<T>, b: Set<T>): boolean {
+    for (const item of a) {
+      if (b.has(item)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Convert set to array.
+   */
+  static toArray<T>(set: Set<T>): Array<T> {
+    return Array.from(set);
+  }
+
+  /**
+   * Create set from array.
+   */
+  static fromArray<T>(arr: Array<T>): Set<T> {
+    return new Set(arr);
+  }
+
+  /**
+   * Filter set by predicate.
+   */
+  static filter<T>(set: Set<T>, predicate: (item: T) => boolean): Set<T> {
+    const result = new Set<T>();
+    for (const item of set) {
+      if (predicate(item)) {
+        result.add(item);
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Map over set values.
+   */
+  static map<T, U>(set: Set<T>, fn: (item: T) => U): Set<U> {
+    const result = new Set<U>();
+    for (const item of set) {
+      result.add(fn(item));
+    }
+    return result;
+  }
+}

package/src/string-tools-gs.ts

@@ -0,0 +1,166 @@
+/**
+ * String parsing utilities with dual error handling pattern.
+ */
+export class StringTools {
+  /**
+   * Parse integer from string. Throws on invalid input.
+   */
+  static parseInt(s: string): number {
+    const result = StringTools.tryParseInt(s);
+    if (result === null) {
+      throw new Error(`Invalid integer: "${s}"`);
+    }
+    return result;
+  }
+
+  /**
+   * Parse integer from string. Returns null on invalid input.
+   */
+  static tryParseInt(s: string): number | null {
+    const trimmed = s.trim();
+    if (trimmed === '') {
+      return null;
+    }
+
+    const parsed = Number.parseInt(trimmed, 10);
+    if (Number.isNaN(parsed)) {
+      return null;
+    }
+
+    // Ensure the entire string was consumed (no trailing garbage)
+    if (!/^-?\d+$/.test(trimmed)) {
+      return null;
+    }
+
+    return parsed;
+  }
+
+  /**
+   * Parse float from string. Throws on invalid input.
+   */
+  static parseFloat(s: string): number {
+    const result = StringTools.tryParseFloat(s);
+    if (result === null) {
+      throw new Error(`Invalid number: "${s}"`);
+    }
+    return result;
+  }
+
+  /**
+   * Parse float from string. Returns null on invalid input.
+   */
+  static tryParseFloat(s: string): number | null {
+    const trimmed = s.trim();
+    if (trimmed === '') {
+      return null;
+    }
+
+    const parsed = Number.parseFloat(trimmed);
+    if (Number.isNaN(parsed)) {
+      return null;
+    }
+
+    return parsed;
+  }
+
+  /**
+   * Check if string contains substring.
+   */
+  static contains(s: string, substring: string): boolean {
+    return s.includes(substring);
+  }
+
+  /**
+   * Check if string starts with prefix.
+   */
+  static startsWith(s: string, prefix: string): boolean {
+    return s.startsWith(prefix);
+  }
+
+  /**
+   * Check if string ends with suffix.
+   */
+  static endsWith(s: string, suffix: string): boolean {
+    return s.endsWith(suffix);
+  }
+
+  /**
+   * Repeat string n times.
+   */
+  static repeat(s: string, count: number): string {
+    if (count < 0) {
+      throw new Error(`Repeat count must be non-negative: ${count}`);
+    }
+    return s.repeat(count);
+  }
+
+  /**
+   * Reverse string.
+   */
+  static reverse(s: string): string {
+    return s.split('').reverse().join('');
+  }
+
+  /**
+   * Pad string to length on left with fillString.
+   */
+  static padLeft(s: string, length: number, fillString: string = ' '): string {
+    return s.padStart(length, fillString);
+  }
+
+  /**
+   * Pad string to length on right with fillString.
+   */
+  static padRight(s: string, length: number, fillString: string = ' '): string {
+    return s.padEnd(length, fillString);
+  }
+
+  /**
+   * Split string by separator.
+   */
+  static split(s: string, separator: string): Array<string> {
+    return s.split(separator);
+  }
+
+  /**
+   * Join array of strings with separator.
+   */
+  static join(parts: Array<string>, separator: string = ''): string {
+    return parts.join(separator);
+  }
+
+  /**
+   * Convert string to uppercase.
+   */
+  static toUpperCase(s: string): string {
+    return s.toUpperCase();
+  }
+
+  /**
+   * Convert string to lowercase.
+   */
+  static toLowerCase(s: string): string {
+    return s.toLowerCase();
+  }
+
+  /**
+   * Trim whitespace from both ends.
+   */
+  static trim(s: string): string {
+    return s.trim();
+  }
+
+  /**
+   * Trim whitespace from left end.
+   */
+  static trimLeft(s: string): string {
+    return s.trimStart();
+  }
+
+  /**
+   * Trim whitespace from right end.
+   */
+  static trimRight(s: string): string {
+    return s.trimEnd();
+  }
+}