Object Utilities

function keys(obj)

import { keys } from '@semantic-ui/utils';

const obj = { a: 1, b: 2, c: 3 };
console.log(keys(obj)); // ['a', 'b', 'c']

function values(obj)

import { values } from '@semantic-ui/utils';

const obj = { a: 1, b: 2, c: 3 };
console.log(values(obj)); // [1, 2, 3]

function filterObject(obj, callback)

import { filterObject } from '@semantic-ui/utils';

const obj = { a: 1, b: 2, c: 3, d: 4 };
const result = filterObject(obj, (value) => value % 2 === 0);
console.log(result); // { b: 2, d: 4 }

function mapObject(obj, callback)

import { mapObject } from '@semantic-ui/utils';

const obj = { a: 1, b: 2, c: 3 };
const result = mapObject(obj, (value) => value * 2);
console.log(result); // { a: 2, b: 4, c: 6 }

function trackWrites(value, callback, { strategy = 'auto', returnPaths = true, keyed = true, fields = elementKey.config.fields, onWrite, clone, equality } = {})

import { trackWrites, get } from '@semantic-ui/utils';

const doc = { meta: { count: 0 } };
const { changed, paths } = trackWrites(doc, (value) => {
  value.meta.count++;
});
console.log(changed); // true
console.log(paths); // ['meta.count']

// paths resolve against the value, e.g. for state sync
paths.forEach((path) => sync(path, get(doc, path)));

// keyed paths by default — a field edit across a collection reads back per
// record, not by index, with zero configuration
const db = { todos: [{ id: 'a', complete: false }, { id: 'b', complete: false }] };
const completeAll = trackWrites(db, (d) => {
  for (const todo of d.todos) { todo.complete = true; }
});
console.log(completeAll.paths); // ['todos[#a].complete', 'todos[#b].complete']

// the proxy strategy is the positional opt-out (no element identity)
trackWrites(db, mutator, { strategy: 'proxy' }); // paths like ['todos.0.complete']

// skip path collection on hot paths
trackWrites(doc, mutator, { returnPaths: false }); // { changed, result }

function trackReads(value, callback, { returnPaths = true, keyed = true, fields = elementKey.config.fields, onRead } = {})

import { trackReads, get } from '@semantic-ui/utils';

const state = { todos: [{ id: 'a', done: false }, { id: 'b', done: true }] };
const { reads, structure } = trackReads(state, (value) =>
  value.todos.map((todo) => todo.done));
console.log(reads);     // ['todos[#a].done', 'todos[#b].done']
console.log(structure); // ['todos']

// reads resolve back through get(), e.g. for a memoization key — and the keyed
// paths survive a reorder of the list
reads.map((path) => get(state, path)); // [false, true]

// pair with the write side: re-run when a read value changes (changed) or when
// a read container grows or shrinks (added/removed)
// reads     ↔ detectChanges.changed
// structure ↔ detectChanges.added / removed

// onRead streams each read live, typed, for dependency collectors
trackReads(state, (value) => value.todos.length, {
  onRead: (path, type) => console.log(type, path), // 'value' todos, 'structure' todos
});

// positional opt-out, and hot-path streaming without collection
trackReads(state, reader, { keyed: false });        // paths like ['todos.0.done']
trackReads(state, reader, { returnPaths: false, onRead });

function detectChanges(before, after, {
  keyed = true,
  fields = elementKey.config.fields,
  equality = isEqual,
  ignoreKeys = null,
  collapseKeys = null,
} = {})

import { detectChanges } from '@semantic-ui/utils';

const before = { name: 'a', temp: true, count: 1 };
const after = { name: 'b', count: 1, nickname: 'al' };

console.log(detectChanges(before, after));
// { added: ['nickname'], removed: ['temp'], changed: ['name'] }

// arrays of keyed objects diff by identity — a prepend plus an edit is one add
const cartBefore = { lineItems: [{ id: 'a', qty: 1 }, { id: 'b', qty: 1 }] };
const cartAfter = { lineItems: [{ id: 'z', qty: 9 }, { id: 'a', qty: 1 }, { id: 'b', qty: 5 }] };
console.log(detectChanges(cartBefore, cartAfter));
// { added: ['lineItems[#z]'], removed: [], changed: ['lineItems[#b].qty'] }

// scalar arrays (no element identity) fall back to the positional walk
console.log(detectChanges({ items: [1, 2, 3] }, { items: [1, 9] }));
// { added: [], removed: ['items.2'], changed: ['items.1'] }

// { keyed: false } restores the positional cascade for keyed objects too
console.log(detectChanges(cartBefore, cartAfter, { keyed: false }));
// { added: ['lineItems.2'], removed: [], changed: ['lineItems.0.id', 'lineItems.0.qty', 'lineItems.1.id'] }

// equality swaps the comparator — '1' and 1 are not a change under ==
console.log(detectChanges({ a: 1 }, { a: '1' }, { equality: (x, y) => x == y }));
// { added: [], removed: [], changed: [] }

// ignoreKeys drops a field at any depth; collapseKeys reports a subtree whole
console.log(detectChanges(
  { name: 'a', _overrides: { 'contacts[#1].field': true }, updatedAt: 1 },
  { name: 'b', _overrides: { 'contacts[#1].field': false }, updatedAt: 2 },
  { ignoreKeys: ['updatedAt'], collapseKeys: ['_overrides'] },
));
// { added: [], removed: [], changed: ['name', '_overrides'] }

function extend(obj, ...sources)

import { extend } from '@semantic-ui/utils';

const obj1 = { a: 1, b: 2 };
const obj2 = { c: 3 };
const obj3 = { d: 4 };
const result = extend(obj1, obj2, obj3);
console.log(result); // { a: 1, b: 2, c: 3, d: 4 }

function assignInPlace(target, source, { preserveExistingKeys = false, preserveGetters = false, returnChanged = false } = {})

import { assignInPlace } from '@semantic-ui/utils';

const config = { host: 'localhost', port: 3000, debug: true };
assignInPlace(config, { host: 'production.app', port: 443 });
console.log(config); // { host: 'production.app', port: 443 } — debug removed

// Preserve existing keys
const settings = { theme: 'light', lang: 'en' };
assignInPlace(settings, { theme: 'dark', fontSize: 14 }, { preserveExistingKeys: true });
console.log(settings); // { theme: 'dark', lang: 'en', fontSize: 14 }

// Preserve computed properties
const view = { name: 'Alice' };
Object.defineProperty(view, 'greeting', { get() { return `Hi, ${this.name}`; }, enumerable: true });
assignInPlace(view, { name: 'Bob' }, { preserveGetters: true });
console.log(view.greeting); // 'Hi, Bob' — getter intact

// Detect changes
const state = { count: 5 };
assignInPlace(state, { count: 5 }, { returnChanged: true }); // false
assignInPlace(state, { count: 10 }, { returnChanged: true }); // true

function deepExtend(obj, ...sources, options)

import { deepExtend } from '@semantic-ui/utils';

const target = {
  user: { name: 'Alice', age: 30 },
  settings: { theme: 'light' }
};

const source = {
  user: { role: 'admin' },
  settings: { notifications: true }
};

deepExtend(target, source);
console.log(target);
// {
//   user: { name: 'Alice', age: 30, role: 'admin' },
//   settings: { theme: 'light', notifications: true }
// }

function pick(obj, ...keys)

import { pick } from '@semantic-ui/utils';

const obj = { a: 1, b: 2, c: 3, d: 4 };
const result = pick(obj, 'a', 'c');
console.log(result); // { a: 1, c: 3 }

function arrayFromObject(obj)

import { arrayFromObject } from '@semantic-ui/utils';

const obj = { a: 1, b: 2, c: 3 };
const result = arrayFromObject(obj);
console.log(result); // [{ key: 'a', value: 1 }, { key: 'b', value: 2 }, { key: 'c', value: 3 }]

function proxyObject(sourceObj = noop, referenceObj = {})

import { proxyObject } from '@semantic-ui/utils';

const source = () => ({ a: 1, b: 2 });
const reference = { c: 3 };
const proxy = proxyObject(source, reference);
console.log(proxy.a); // 1
console.log(proxy.c); // 3

function onlyKeys(obj, keysToKeep)

import { onlyKeys } from '@semantic-ui/utils';

const obj = { a: 1, b: 2, c: 3, d: 4 };
const result = onlyKeys(obj, ['a', 'c']);
console.log(result); // { a: 1, c: 3 }

function hasProperty(obj, prop)

import { hasProperty } from '@semantic-ui/utils';

const obj = { a: 1, b: 2 };
console.log(hasProperty(obj, 'a')); // true
console.log(hasProperty(obj, 'toString')); // false

function reverseKeys(obj)

import { reverseKeys } from '@semantic-ui/utils';

const obj = { a: '1', b: ['2', '3'] };
const result = reverseKeys(obj);
console.log(result); // { '1': 'a', '2': 'b', '3': 'b' }

function weightedObjectSearch(query, objectArray, { returnMatches = false, matchAllWords = true, propertiesToMatch = [] } = {})

import { weightedObjectSearch } from '@semantic-ui/utils';

const items = [
  { title: 'Hello World', desc: 'A greeting' },
  { title: 'World News', desc: 'Current events' }
];

// Basic search
const results = weightedObjectSearch('world', items, {
  propertiesToMatch: ['title', 'desc']
});

// With match details (does not mutate originals)
const detailed = weightedObjectSearch('world', items, {
  propertiesToMatch: ['title', 'desc'],
  returnMatches: true,
});
// detailed[0].matches → [{ field: 'title', type: 'startsWith', score: 1, value: 'World News' }]