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, keys = ['id', '_id', 'hash', 'key'], 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 elementKey(item, keys = ['id', '_id', 'hash', 'key'])

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

console.log(elementKey({ id: 'a', _id: 'x' })); // 'a'
console.log(elementKey({ name: 'n' }));         // undefined
console.log(elementKey({ sku: 's1' }, ['sku'])); // 's1'

function detectChanges(before, after, { keyed = true, keys = ['id', '_id', 'hash', 'key'] } = {})

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'] }

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 get(obj, path = '', keys = ['id', '_id', 'hash', 'key'])

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

const obj = { a: { b: { c: 42 } } };
console.log(get(obj, 'a.b.c')); // 42
console.log(get(obj, 'a.b.d')); // undefined

const doc = { items: [{ id: 'a', n: 1 }, { id: 'b', n: 2 }] };
console.log(get(doc, 'items[#b].n')); // 2 (selected by identity, not position)

function set(obj, path, value, keys = ['id', '_id', 'hash', 'key'])

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

console.log(set({}, 'a.b.c', 1)); // { a: { b: { c: 1 } } }
console.log(set({}, 'items.0.name', 'first')); // { items: [{ name: 'first' }] }

// sync changes between objects
const { paths } = trackWrites(source, mutator);
paths.forEach((path) => set(replica, path, get(source, path)));

// keyed addressing — replace by identity, append when absent
const doc = { items: [{ id: 'a', n: 1 }] };
set(doc, 'items[#a]', { id: 'a', n: 100 }); // replaces in place
set(doc, 'items[#b]', { id: 'b', n: 2 });   // appends, no element had id 'b'

function unset(obj, path, keys = ['id', '_id', 'hash', 'key'])

import { unset, set, get, detectChanges } from '@semantic-ui/utils';

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

// apply a full diff
const diff = detectChanges(before, after);
[...diff.added, ...diff.changed].forEach((path) => set(replica, path, get(after, path)));
diff.removed.forEach((path) => unset(replica, path));

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' }

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' }]