@rhombus-toolkit/obj 0.0.0-placeholder.0 → 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 rhombus-toolkit
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/bundle/index.d.ts

@@ -0,0 +1,262 @@
+import { Store, Flatten, UnionToTuple, DeepDictionary, Func, Falsy, Cast } from '@rhombus-toolkit/types';
+
+type Entry<Key extends PropertyKey = PropertyKey, Value = any> = readonly [Key, Value];
+/** The keys `Object.keys` lists — string-named, so a symbol-named member never appears. */
+type StringKey<T> = Extract<keyof T, string>;
+/** A key the runtime hoists ahead of the others and lists in ascending numeric order. */
+type IndexKey<T> = Extract<keyof T, number | `${number}`>;
+/** A member declared with `?`, which the object at hand may or may not carry. */
+type OptionalKey<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? K : never;
+}[keyof T];
+/**
+ * Every reason `T`'s keys cannot be spelled as a tuple.
+ *
+ * @remarks
+ * Where this is inhabited, {@link keys} and {@link entries} keep only their array arm. Each member
+ * disqualifies for its own reason: an {@link IndexKey} is listed first and numerically rather than
+ * in the order the type holds it, and sorting it into place is not something the type system does
+ * cheaply; an {@link OptionalKey} may be absent at the call, so neither the length nor any position
+ * after it is fixed; and a `string` index signature admits any number of keys, which would otherwise
+ * be tupled as the single key `string`.
+ *
+ * `${number}` also matches spellings that are not array indices — `'1.5'`, `'-3'` — costing an
+ * object keyed that way its tuple and nothing else.
+ */
+type Untuplable<T> = IndexKey<T> | OptionalKey<T> | (string extends StringKey<T> ? string : never);
+type keyTuple<T extends {}> = UnionToTuple<StringKey<T>>;
+/**
+ * The string keys `Object.keys` yields.
+ *
+ * @remarks
+ * The tuple arm carries the order and is withheld whenever {@link Untuplable} finds a reason to
+ * doubt it. The array arm is unconditional, so `map` and the rest stay reachable while `T` is still
+ * a type parameter — a position where neither the tuple nor the test in front of it can be
+ * evaluated, and an unevaluated conditional carries no members at all.
+ */
+type keys<T extends {}> = ([Untuplable<T>] extends [never] ? keyTuple<T> : unknown) & ReadonlyArray<StringKey<T>>;
+declare function keys<T extends {}>(obj: T): keys<T>;
+/** The members `Object.values` yields, symbol-named ones excluded as the runtime excludes them. */
+type values<T extends {}> = T[StringKey<T>];
+declare function values<T extends {}>(obj: T): Array<values<T>>;
+/** Every pair `T` can yield, each key carrying its own member type rather than the union of all. */
+type AnyEntry<T extends {}> = {
+    [K in StringKey<T>]: Entry<K, T[K]>;
+}[StringKey<T>];
+/**
+ * The `[key, value]` pairs `Object.entries` yields, in the order {@link keys} lists them.
+ *
+ * @remarks
+ * Withholds its tuple arm on the same condition as {@link keys}, and keeps its array arm for the
+ * same reason.
+ */
+type entries<T extends {}> = ([Untuplable<T>] extends [never] ? keysToEntries<T, keyTuple<T>> : unknown) & ReadonlyArray<AnyEntry<T>>;
+declare function entries<T extends {}>(obj: T): entries<T>;
+/**
+ * `Keys` paired with the member each one names on `T`.
+ *
+ * @remarks
+ * The key tuple arrives as a parameter rather than being computed inline so the mapped type reads it
+ * as a tuple and hands back a tuple; mapping straight over an unevaluated conditional maps something
+ * that contributes `length` and the array methods as members of its own.
+ */
+type keysToEntries<T extends {}, Keys extends ReadonlyArray<StringKey<T>>> = {
+    [K in keyof Keys]: Entry<Keys[K], T[Keys[K]]>;
+};
+type fromEntries<TUnion extends Entry> = {
+    [T in TUnion as T[0]]: T[1];
+};
+declare function fromEntries<TEntry extends Entry>(entries: readonly TEntry[]): fromEntries<TEntry>;
+type _assign<Sources extends readonly any[], Result extends {}> = Sources extends readonly [...infer Rest, infer Last] ? _assign<Rest, ShallowMerge<Last, Result>> : Result;
+/**
+ * The result of `Object.assign(target, ...sources)`: each source shallow-merged over the one before
+ * it, left to right.
+ *
+ * @remarks
+ * Arrays and objects merge differently, so {@link ShallowMerge} dispatches on the pair. Two arrays
+ * merge INDEX-WISE and the result is as long as the longer of them, which is what makes a short
+ * overlay leave the tail alone. Anything else merges by key.
+ */
+type assign<Sources extends readonly any[]> = _assign<Sources, Sources[0] extends readonly any[] ? [] : {}>;
+declare function assign<Target extends object, Sources extends any[]>(target: Target, ...sources: Sources): assign<[Target, ...Sources]>;
+type ShallowMerge<A, B> = A extends readonly any[] ? B extends readonly any[] ? MergeArrays<A, B> : MergeObjects<A, B> : MergeObjects<A, B>;
+/**
+ * `B` overlaid on `A` index-wise, walking one position at a time and stopping once both are spent.
+ * The result is as long as the longer of the two, which is what leaves a short overlay's tail alone.
+ *
+ * @remarks
+ * The walk's budget is a tuple peeled one cell per step rather than a number run down through
+ * `Dec`. `Dec<N>` is `Length<Tail<Counter<N>>>` and `Counter` recurses without a bound while its
+ * argument is still a parameter, so relating `Dec<TTL>` back to a `TTL extends number` constraint
+ * fails at this declaration with "Excessive stack depth" — the same reason `counter`'s own
+ * `Subtract` peels tuples instead of routing through `Skip`. It only compiled before because the
+ * `Dec` in scope was a generated lookup table, which this package's move onto
+ * `@rhombus-toolkit/types` retires.
+ */
+type MergeArrays<A extends readonly any[], B extends readonly any[]> = _MergeArrays<Store<15>, A, B, [], []>;
+type _MergeArrays<TTL extends readonly any[], A extends readonly any[], B extends readonly any[], I extends readonly any[], Acc extends readonly any[]> = TTL extends readonly [any, ...infer TTLRest] ? Spent<A, B, I> extends true ? Acc : _MergeArrays<TTLRest, A, B, [...I, any], [...Acc, MergeValue<A, B, I['length']>]> : never;
+/**
+ * `B`'s element at this index, falling back to `A`'s where `B` has none.
+ *
+ * @remarks
+ * `undefined` counts as "none". A tuple type cannot tell a hole (`[, 7]`) from an explicit
+ * `undefined` — both read as `undefined` — so falling back is the only reading available, and it is
+ * the one a sparse overlay wants. It does diverge from the runtime, where an explicit `undefined`
+ * overwrites.
+ */
+type MergeValue<A extends readonly any[], B extends readonly any[], N extends number> = At<B, N> extends undefined ? At<A, N> : At<B, N>;
+type MergeObjects<A, B> = Flatten<Omit<A, keyof B> & B>;
+/** `T`'s element at `N`, or `undefined` where `T` is too short to have one. */
+type At<T extends readonly any[], N extends number> = N extends keyof T ? T[N] : undefined;
+/** Whether the walk has reached the end of both `A` and `B`. */
+type Spent<A extends readonly any[], B extends readonly any[], I extends readonly any[]> = Covers<A, I> extends true ? Covers<B, I> extends true ? true : false : false;
+/**
+ * Whether `I` has walked past everything `T` can offer.
+ *
+ * @remarks
+ * A length of `number` rather than a literal means an unbounded array, or a type parameter still
+ * standing in for one. There is no index to walk to, so such an operand is covered from the start
+ * and contributes nothing. Without that, a merge inside a generic function has no base case and
+ * the checker gives up with an excessive-stack-depth error.
+ */
+type Covers<T extends readonly any[], I extends readonly any[]> = number extends T['length'] ? true : keyof T extends keyof I ? true : false;
+
+type obj_AnyEntry<T extends {}> = AnyEntry<T>;
+type obj_Entry<Key extends PropertyKey = PropertyKey, Value = any> = Entry<Key, Value>;
+declare const obj_assign: typeof assign;
+declare const obj_entries: typeof entries;
+declare const obj_fromEntries: typeof fromEntries;
+declare const obj_keys: typeof keys;
+type obj_keysToEntries<T extends {}, Keys extends ReadonlyArray<StringKey<T>>> = keysToEntries<T, Keys>;
+declare const obj_values: typeof values;
+declare namespace obj {
+  export { obj_assign as assign, obj_entries as entries, obj_fromEntries as fromEntries, obj_keys as keys, obj_values as values };
+  export type { obj_AnyEntry as AnyEntry, obj_Entry as Entry, obj_keysToEntries as keysToEntries };
+}
+
+declare function join<S1 extends string, S2 extends string>(a: S1, b: S2): join<S1, S2>;
+/**
+ * `A` and `B` dot-joined, either one being empty giving the other back on its own.
+ *
+ * @remarks
+ * Every arm is `string`-shaped, `Cast<B, string>` included: a `B` of `symbol` or `number` has no
+ * literal spelling, so it widens to `string` rather than escaping as a non-string key. Without that
+ * the empty-`A` arm handed a bare `PropertyKey` to `_flattenMap`'s `prefix extends string`.
+ */
+type join<A extends string, B extends PropertyKey> = A extends Falsy ? Cast<B, string> : B extends Falsy ? A : `${A}.${Cast<B, string>}`;
+/**
+ * The descent, `Budget` spending one cell per level.
+ *
+ * @remarks
+ * A tuple rather than a number run down through `Dec`: `Dec<N>` is `Length<Tail<Counter<N>>>`, and
+ * relating that back to a `number`-constrained parameter drags `Counter`'s unbounded recursion into
+ * the comparison, which fails at this declaration with "Excessive stack depth". `Store<MaxDepth>`
+ * does the number-to-tuple conversion once, at the public entry, so the depth stays a plain number
+ * for a caller.
+ */
+type _flattenMap<T extends DeepDictionary<any>, Leaf, prefix extends string, Budget extends readonly any[]> = Budget extends readonly [any, ...infer Rest] ? T extends Leaf ? [prefix, T] : T extends Record<any, any> ? {
+    [K in keyof T]: _flattenMap<T[K], Leaf, join<prefix, K>, Rest>;
+}[keyof T] : never : never;
+/**
+ * `T`'s leaves keyed by the dot-joined path each one sits at.
+ *
+ * @remarks
+ * Both defaults exist to keep the one-argument `flattenMap<M>` of the version
+ * this replaces spelling the same type. That version hardcoded its leaf as
+ * {@link Func} and guarded at a depth of 10, so a `TLeaf` of anything else or a
+ * `MaxDepth` below 10 would quietly turn a map that used to flatten into
+ * `never`.
+ */
+type flattenMap<T extends DeepDictionary<any>, TLeaf = Func, MaxDepth extends number = 10> = fromEntries<_flattenMap<T, TLeaf, '', Store<MaxDepth>>>;
+/** Flattens `map` with `isFunction` as the leaf test — the shape the superseded version had. */
+declare function flattenMap<T extends DeepDictionary<Func>>(map: T): flattenMap<T>;
+/**
+ * Flattens `map`, `leafPredicate` deciding what counts as a leaf.
+ *
+ * The predicate is spelled out rather than reached for as a `Func`: a type
+ * guard's return is a type predicate, which `Func`'s `Return` parameter has no
+ * way to carry.
+ */
+declare function flattenMap<T extends DeepDictionary<Leaf>, Leaf>(map: T, leafPredicate: (p: any) => p is Leaf): flattenMap<T, Leaf>;
+
+/** Yields every element of `source`, substituting `replacement` for each one `match` selects — an exact value or a predicate. */
+declare function replace<T>(source: Iterable<T>, match: T | Func<[T], boolean>, replacement: Func<[T], T>): Generator<T>;
+declare function replace<T, U>(source: Iterable<T>, match: T | Func<[T], boolean>, replacement: Func<[T], U>): Generator<T | U>;
+declare function replace<T>(source: Iterable<T>, match: T | Func<[T], boolean>, replacement: T): Generator<T>;
+declare function replace<T, U>(source: Iterable<T>, match: T | Func<[T], boolean>, replacement: U): Generator<T | U>;
+/** The first element `source` yields, or `undefined` when it yields nothing. */
+declare function first<T>(source: Iterable<T>): T | undefined;
+/**
+ * Type guard: whether every element of `items` is present — none are `undefined`.
+ *
+ * @remarks
+ * Deciding this reads `items` to the end, so a one-shot source is spent by the call and the
+ * narrowed value it hands back yields nothing. Pass an array, a `Set`, or anything else that can
+ * be iterated twice.
+ */
+declare function isAllThere<T>(items: ReadonlyArray<T | undefined>): items is readonly T[];
+declare function isAllThere<T>(items: Iterable<T | undefined>): items is Iterable<T>;
+/**
+ * Yields each argument's elements in order, an argument that is not iterable yielded as itself.
+ *
+ * @remarks
+ * `Iterable<T> | T` is genuinely ambiguous once `T` is itself iterable, and `isIterable` is the
+ * only arbiter at runtime: a `T` of `string` arrives flattened into its characters, since a string
+ * carries `Symbol.iterator`. The `Iterator.from` on the iterable arm is what makes that hold rather
+ * than throw — `flatMap` rejects a primitive outright, where `Iterator.from` iterates a string.
+ */
+declare function concat<T>(...args: ReadonlyArray<Iterable<T> | T>): IteratorObject<T, undefined, unknown>;
+/** Wraps an iterator factory as an `Iterable`, so every walk over the result asks `fn` for a fresh iterator. */
+declare function iterable<T>(fn: Func<[], Iterator<T>>): Iterable<T>;
+/**
+ * Yields tuples pairing the sources' elements positionally. `inner` ends with the shortest source,
+ * every slot present; `outer` runs to the longest, an exhausted source's slot `undefined` — which a
+ * source yielding `undefined` is indistinguishable from.
+ */
+declare function zip<T1, T2>(mode: 'inner', source1: Iterable<T1>, source2: Iterable<T2>): Generator<[T1, T2]>;
+declare function zip<T1, T2, T3>(mode: 'inner', source1: Iterable<T1>, source2: Iterable<T2>, source3: Iterable<T3>): Generator<[T1, T2, T3]>;
+declare function zip<T1, T2, T3, T4>(mode: 'inner', source1: Iterable<T1>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>): Generator<[T1, T2, T3, T4]>;
+declare function zip<T1, T2, T3, T4, T5>(mode: 'inner', source1: Iterable<T1>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>): Generator<[T1, T2, T3, T4, T5]>;
+declare function zip<T1, T2, T3, T4, T5, T6>(mode: 'inner', source1: Iterable<T1>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>, source6: Iterable<T6>): Generator<[T1, T2, T3, T4, T5, T6]>;
+declare function zip<T1, T2, T3, T4, T5, T6, T7>(mode: 'inner', source1: Iterable<T1>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>, source6: Iterable<T6>, source7: Iterable<T7>): Generator<[T1, T2, T3, T4, T5, T6, T7]>;
+declare function zip<T1, T2, T3, T4, T5, T6, T7, T8>(mode: 'inner', source1: Iterable<T1>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>, source6: Iterable<T6>, source7: Iterable<T7>, source8: Iterable<T8>): Generator<[T1, T2, T3, T4, T5, T6, T7, T8]>;
+declare function zip<T1, T2, T3, T4, T5, T6, T7, T8, T9>(mode: 'inner', source1: Iterable<T1>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>, source6: Iterable<T6>, source7: Iterable<T7>, source8: Iterable<T8>, source9: Iterable<T9>): Generator<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>;
+declare function zip<T1, T2>(mode: 'outer', source1: Iterable<T1>, source2: Iterable<T2>): Generator<[T1 | undefined, T2 | undefined]>;
+declare function zip<T1, T2, T3>(mode: 'outer', source1: Iterable<T1>, source2: Iterable<T2>, source3: Iterable<T3>): Generator<[T1 | undefined, T2 | undefined, T3 | undefined]>;
+declare function zip<T1, T2, T3, T4>(mode: 'outer', source1: Iterable<T1>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>): Generator<[T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined]>;
+declare function zip<T1, T2, T3, T4, T5>(mode: 'outer', source1: Iterable<T1>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>): Generator<[T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined, T5 | undefined]>;
+declare function zip<T1, T2, T3, T4, T5, T6>(mode: 'outer', source1: Iterable<T1>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>, source6: Iterable<T6>): Generator<[T1 | undefined, T2 | undefined, T3 | undefined, T4 | undefined, T5 | undefined, T6 | undefined]>;
+declare function zip<T1, T2, T3, T4, T5, T6, T7>(mode: 'outer', source1: Iterable<T1>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>, source6: Iterable<T6>, source7: Iterable<T7>): Generator<[
+    T1 | undefined,
+    T2 | undefined,
+    T3 | undefined,
+    T4 | undefined,
+    T5 | undefined,
+    T6 | undefined,
+    T7 | undefined
+]>;
+declare function zip<T1, T2, T3, T4, T5, T6, T7, T8>(mode: 'outer', source1: Iterable<T1>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>, source6: Iterable<T6>, source7: Iterable<T7>, source8: Iterable<T8>): Generator<[
+    T1 | undefined,
+    T2 | undefined,
+    T3 | undefined,
+    T4 | undefined,
+    T5 | undefined,
+    T6 | undefined,
+    T7 | undefined,
+    T8 | undefined
+]>;
+declare function zip<T1, T2, T3, T4, T5, T6, T7, T8, T9>(mode: 'outer', source1: Iterable<T1>, source2: Iterable<T2>, source3: Iterable<T3>, source4: Iterable<T4>, source5: Iterable<T5>, source6: Iterable<T6>, source7: Iterable<T7>, source8: Iterable<T8>, source9: Iterable<T9>): Generator<[
+    T1 | undefined,
+    T2 | undefined,
+    T3 | undefined,
+    T4 | undefined,
+    T5 | undefined,
+    T6 | undefined,
+    T7 | undefined,
+    T8 | undefined,
+    T9 | undefined
+]>;
+/** Whether the sources yield pairwise-equal elements and end together. */
+declare function sequenceEquals<T>(source1: Iterable<T>, source2: Iterable<T>, equals: Func<[left: T, right: T], boolean>): boolean;
+
+export { concat, first, flattenMap, isAllThere, iterable, obj, replace, sequenceEquals, zip };

package/dist/bundle/index.js

@@ -0,0 +1,119 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// src/flattenMap.ts
+import { isFunction } from "@rhombus-toolkit/type-guards";
+
+// src/obj.ts
+var exports_obj = {};
+__export(exports_obj, {
+  values: () => values,
+  keys: () => keys,
+  fromEntries: () => fromEntries,
+  entries: () => entries,
+  assign: () => assign
+});
+function keys(obj) {
+  return Object.keys(obj);
+}
+function values(obj) {
+  return Object.values(obj);
+}
+function entries(obj) {
+  return Object.entries(obj);
+}
+function fromEntries(entries2) {
+  return Object.fromEntries(entries2);
+}
+function assign(target, ...sources) {
+  return Object.assign(target, ...sources);
+}
+
+// src/flattenMap.ts
+function join(a, b) {
+  return [a, b].filter(Boolean).join(".");
+}
+function flattenMap(map, leafPredicate = isFunction) {
+  const result = [];
+  const stack = Object.entries(map);
+  while (stack.length) {
+    const [prefix, branchOrLeaf] = stack.pop();
+    if (leafPredicate(branchOrLeaf)) {
+      result.push([prefix, branchOrLeaf]);
+    } else {
+      Object.entries(branchOrLeaf).forEach(([key, p]) => stack.push([join(prefix, key), p]));
+    }
+  }
+  return fromEntries(result);
+}
+// src/iterable.ts
+import { isFunction as isFunction2, isIterable } from "@rhombus-toolkit/type-guards";
+function* replace(source, match, replacement) {
+  const predicate = isFunction2(match) ? match : (item) => item === match;
+  for (const item of source) {
+    yield predicate(item) ? isFunction2(replacement) ? replacement(item) : replacement : item;
+  }
+}
+function first(source) {
+  for (const value of source) {
+    return value;
+  }
+  return;
+}
+function isAllThere(items) {
+  return Iterator.from(items).every((item) => item !== undefined);
+}
+function concat(...args) {
+  return Iterator.from(args).flatMap((item) => isIterable(item) ? Iterator.from(item) : [item]);
+}
+function iterable(fn) {
+  return { [Symbol.iterator]: fn };
+}
+function* zip(mode, ...sources) {
+  const iterators = sources.map((source) => Iterator.from(source));
+  while (true) {
+    const results = iterators.map((iterator) => iterator.next());
+    const ended = mode === "inner" ? results.some((result) => result.done) : results.every((result) => result.done);
+    if (ended) {
+      return;
+    }
+    yield results.map((result) => result.value);
+  }
+}
+function sequenceEquals(source1, source2, equals) {
+  const left = Iterator.from(source1);
+  const right = Iterator.from(source2);
+  while (true) {
+    const first2 = left.next();
+    const second = right.next();
+    if (first2.done || second.done) {
+      return (first2.done ?? false) === (second.done ?? false);
+    }
+    if (!equals(first2.value, second.value)) {
+      return false;
+    }
+  }
+}
+export {
+  zip,
+  sequenceEquals,
+  replace,
+  exports_obj as obj,
+  iterable,
+  isAllThere,
+  flattenMap,
+  first,
+  concat
+};

package/package.json

@@ -1,9 +1,7 @@
 {
   "name": "@rhombus-toolkit/obj",
-  "version": "0.0.0-placeholder.0",
-  "description": "PLACEHOLDER — name reservation only. Real content lands in a 1.0.0-next release.",
-  "license": "MIT",
-  "author": "Thomas Butler",
+  "version": "1.0.1",
+  "description": "Typed counterparts of the Object.* statics, plus flattenMap.",
   "repository": {
     "type": "git",
     "url": "https://github.com/rhombus-toolkit/ts.git",
@@ -11,10 +9,31 @@
   },
   "type": "module",
   "sideEffects": false,
+  "main": "./dist/bundle/index.js",
+  "types": "./dist/bundle/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/bundle/index.d.ts",
+      "import": "./dist/bundle/index.js",
+      "default": "./dist/bundle/index.js"
+    }
+  },
   "files": [
-    "README.md"
+    "dist"
   ],
+  "keywords": [],
+  "author": "Thomas Butler",
+  "dependencies": {
+    "@rhombus-toolkit/type-guards": "2.0.1",
+    "@rhombus-toolkit/types": "1.0.1"
+  },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "bun ../../scripts/build-lib.ts",
+    "lint": "bun x tsc --noEmit -p tsconfig.ci.json",
+    "test": "bun test"
   }
-}
+}

package/README.md

@@ -1,13 +0,0 @@
-# @rhombus-toolkit/obj
-
-**This version is a placeholder. It contains no code.**
-
-It exists only to reserve the package name so that npm Trusted Publishing can be
-configured ahead of the first real release. Do not depend on this version.
-
-Real content ships as `1.0.0-next.x` on the `next` dist-tag.
-
-This package will hold the typed counterparts of the `Object.*` statics —
-`keys`, `values`, `entries`, `fromEntries`, `assign` — each a type and a wrapper
-function declaration-merged under one name, moved out of
-`@rhombus-toolkit/type-helpers`.