@golemui/core 0.0.2

package/lib/utils/object.d.ts

@@ -0,0 +1,140 @@
+import { DotPath } from '../shared';
+/**
+ * Retrieves a value from a nested object using a dot-separated path.
+ *
+ * This function safely navigates through nested objects and arrays using a dot notation
+ * path string. It handles both object properties and array indices.
+ *
+ * @param obj - The object to retrieve the value from
+ * @param path - A dot-separated string path to the desired value (e.g., "user.profile.name" or "items.0.title")
+ * @returns The value at the specified path, or undefined if the path doesn't exist
+ *
+ * @example
+ * Basic object navigation:
+ * ```typescript
+ * const user = { profile: { name: "John", age: 30 } };
+ * get(user, "profile.name"); // Returns "John"
+ * get(user, "profile.age");  // Returns 30
+ * ```
+ *
+ * @example
+ * Array access with indices:
+ * ```typescript
+ * const data = { users: [{ name: "Alice" }, { name: "Bob" }] };
+ * get(data, "users.0.name"); // Returns "Alice"
+ * get(data, "users.1.name"); // Returns "Bob"
+ * ```
+ *
+ * @example
+ * Mixed object and array navigation:
+ * ```typescript
+ * const complex = {
+ *   teams: [
+ *     { name: "Engineering", members: [{ role: "Lead" }, { role: "Dev" }] },
+ *     { name: "Design", members: [{ role: "Senior" }] }
+ *   ]
+ * };
+ * get(complex, "teams.0.name");           // Returns "Engineering"
+ * get(complex, "teams.0.members.1.role"); // Returns "Dev"
+ * ```
+ *
+ * @example
+ * Handling non-existent paths:
+ * ```typescript
+ * const obj = { a: { b: "value" } };
+ * get(obj, "a.b");     // Returns "value"
+ * get(obj, "a.c");     // Returns undefined
+ * get(obj, "x.y.z");   // Returns undefined
+ * ```
+ */
+export declare const get: <T = any>(obj: Record<string, any>, path: DotPath) => T;
+/**
+ * Sets the value at path of object by mutation.
+ * If a portion of path doesn't exist, it's created.
+ * Arrays are created for missing index properties while objects are created for all other missing properties.
+ *
+ * @param object - The object to modify
+ * @param path - The path of the property to set (dot notation)
+ * @param value - The value to set
+ * @returns The modified object (mutates the original object)
+ *
+ * @example
+ * Basic property setting:
+ * ```typescript
+ * const obj = { a: 1 };
+ * set(obj, 'b', 2);
+ * // Result: { a: 1, b: 2 }
+ * ```
+ *
+ * @example
+ * Nested property creation:
+ * ```typescript
+ * const obj = {};
+ * set(obj, 'user.name', 'John');
+ * // Result: { user: { name: 'John' } }
+ * ```
+ *
+ * @example
+ * Deep nested path creation:
+ * ```typescript
+ * const obj = {};
+ * set(obj, 'config.api.endpoints.users', '/api/v1/users');
+ * // Result: { config: { api: { endpoints: { users: '/api/v1/users' } } } }
+ * ```
+ *
+ * @example
+ * Array index creation:
+ * ```typescript
+ * const obj = {};
+ * set(obj, 'items.0', 'first item');
+ * set(obj, 'items.2', 'third item');
+ * // Result: { items: ['first item', undefined, 'third item'] }
+ * ```
+ *
+ * @example
+ * Mixed object and array paths:
+ * ```typescript
+ * const obj = {};
+ * set(obj, 'users.0.name', 'Alice');
+ * set(obj, 'users.0.age', 25);
+ * set(obj, 'users.1.name', 'Bob');
+ * // Result: { users: [{ name: 'Alice', age: 25 }, { name: 'Bob' }] }
+ * ```
+ *
+ * @example
+ * Overwriting existing values:
+ * ```typescript
+ * const obj = { user: { name: 'John', age: 30 } };
+ * set(obj, 'user.name', 'Jane');
+ * set(obj, 'user.email', 'jane@example.com');
+ * // Result: { user: { name: 'Jane', age: 30, email: 'jane@example.com' } }
+ * ```
+ *
+ * @example
+ * Working with existing arrays:
+ * ```typescript
+ * const obj = { items: ['a', 'b'] };
+ * set(obj, 'items.5', 'f');
+ * // Result: { items: ['a', 'b', undefined, undefined, undefined, 'f'] }
+ * ```
+ */
+export declare const set: (object: Record<string, any>, path: DotPath, value: any) => Record<string, any>;
+/**
+ * Deletes a key from an object and returns the same mutated object.
+ *
+ * @param object - The object to remove the key from.
+ * @param key - The property name to delete.
+ * @returns The same object, with the specified key removed.
+ *
+ * @example
+ * ```ts
+ * const obj = { a: 1, b: 2, c: 3 };
+ * deleteKey(obj, "b");
+ * console.log(obj); // { a: 1, c: 3 }
+ * ```
+ */
+export declare const deleteKey: (object: Record<string, any>, key: string) => Record<string, any>;
+/**
+ * Cheap JSON.stringify-based clone object utility
+ */
+export declare function cloneObject(obj: Record<string, any>): any;

package/lib/utils/random.d.ts

@@ -0,0 +1 @@
+export declare const shortUUID: () => string;

package/lib/utils/repeater.d.ts

@@ -0,0 +1,2 @@
+import { NonFunctionWidget } from '../form-widget';
+export declare function makeRepeaterItemConfig(widget: NonFunctionWidget<string>, repeaterIndex: number): NonFunctionWidget<string>;

package/lib/utils/suffixable.d.ts

@@ -0,0 +1,16 @@
+type Suffixable<T, K extends keyof T, TSuffixes extends string> = {
+    [P in keyof T as P extends K ? never : P]: T[P];
+} & {
+    [P in K as P]: T[P];
+} & {
+    [P in K as `${string & P}.${TSuffixes}`]?: T[P];
+};
+export type SomeSuffixable<T extends Record<string, any>, P extends Partial<keyof T>, TSuffixes extends string = string> = Suffixable<T, P, TSuffixes>;
+export type AllSuffixable<T extends Record<string, any>, TSuffixes extends string> = Suffixable<T, keyof T, TSuffixes>;
+/**
+ * Takes a type T and an exclusion set E
+ * @example
+ * type OnExceptFocus = AllSuffixableExcept<On, 'focus'>;
+ */
+export type AllSuffixableExcept<T extends Record<string, any>, E extends keyof T, TSuffixes extends string> = Suffixable<T, Exclude<keyof T, E>, TSuffixes>;
+export {};

package/lib/utils/types.d.ts

@@ -0,0 +1,63 @@
+/**
+ * LooseUnion<T> - Creates a string union that provides autocomplete while accepting any string.
+ *
+ * This utility type allows you to define a set of recommended string values that appear in
+ * IDE autocomplete, while still accepting any arbitrary string value without type errors.
+ * This is useful for APIs where you want to suggest common values but not restrict users.
+ *
+ * @example
+ * // Define common HTTP methods with autocomplete, but allow custom methods
+ * type HttpMethod = LooseUnion<"GET" | "POST" | "PUT" | "DELETE">;
+ *
+ * const method1: HttpMethod = "GET"; // Autocomplete suggests: GET, POST, PUT, DELETE
+ * const method2: HttpMethod = "PATCH"; // Also accepts any other string
+ *
+ * @example
+ * // CSS color names with autocomplete, but allow hex/rgb values
+ * type Color = LooseUnion<"red" | "blue" | "green">;
+ *
+ * const color1: Color = "red"; // Autocomplete shows common colors
+ * const color2: Color = "#ff0000"; // But also accepts custom values
+ */
+export type LooseUnion<T extends string> = T | (string & {});
+/**
+ * Prettify<T> - Flattens and displays complex TypeScript types in a readable format.
+ *
+ * This utility type takes a complex type (especially unions of intersections) and
+ * "expands" it in IDE tooltips and error messages, making it easier to see all
+ * properties at once instead of seeing multiple intersected types.
+ *
+ * @example
+ * type User = { id: number; name: string };
+ * type Timestamps = { createdAt: Date; updatedAt: Date };
+ *
+ * // Without Prettify: IDE shows "User & Timestamps"
+ * type UserWithTimestamps = User & Timestamps;
+ *
+ * // With Prettify: IDE shows the expanded type:
+ * // { id: number; name: string; createdAt: Date; updatedAt: Date }
+ * type PrettifiedUser = Prettify<User & Timestamps>;
+ */
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+/**
+ * Recursively makes all properties of a type deeply immutable and read-only.
+ *
+ * @template T - The type to make immutable
+ * @returns A type where:
+ * - Arrays are converted to readonly arrays with immutable elements
+ * - Objects have all properties converted to readonly with immutable values
+ * - Primitive types remain unchanged
+ *
+ * @example
+ * ```typescript
+ * type User = { name: string; age: number; tags: string[] };
+ * type ImmutableUser = ImmutableRecord<User>;
+ * // Result: { readonly name: string; readonly age: number; readonly tags: readonly string[] }
+ * ```
+ */
+export type ImmutableRecord<T> = T;
+export type _ImmutableRecord<T> = T extends (infer R)[] ? ReadonlyArray<ImmutableRecord<R>> : T extends object ? {
+    readonly [P in keyof T]: ImmutableRecord<T[P]>;
+} : T;

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@golemui/core",
+  "version": "0.0.2",
+  "type": "module",
+  "main": "./index.umd.cjs",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./index.umd.cjs"
+    }
+  },
+  "files": [
+    "lib",
+    "index.d.ts",
+    "index.js",
+    "index.umd.cjs",
+    "*.md"
+  ],
+  "dependencies": {
+    "ts.data.json": "^3.3.0"
+  },
+  "peerDependencies": {
+    "subscript": "^10.1.8",
+    "rxjs": "^7.8.0",
+    "@standard-schema/spec": "^1.0.0"
+  }
+}