@bcts/known-values 1.0.0-alpha.10

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["KNOWN_VALUE_TAG: Tag"],"sources":["../src/known-value.ts","../src/known-values-store.ts","../src/known-values-registry.ts"],"sourcesContent":["/**\n * A value in a namespace of unsigned integers that represents a stand-alone\n * ontological concept.\n *\n * Known Values provide a compact, deterministic way to represent commonly used\n * ontological concepts such as relationships between entities, classes of\n * entities, properties, or enumerated values. They are particularly useful as\n * predicates in Gordian Envelope assertions, offering a more compact and\n * deterministic alternative to URIs. However, known values are not exclusive\n * to Gordian Envelopes and can be used in any context where a compact, unique\n * identifier for a concept is needed.\n *\n * A Known Value is represented as a 64-bit unsigned integer with an optional\n * human-readable name. This approach ensures:\n *\n * - **Compact binary representation** - Each Known Value requires only 1-9\n *   bytes depending on value range\n * - **Deterministic encoding** - Every concept has exactly one valid binary\n *   representation\n * - **Enhanced security** - Eliminates URI manipulation vulnerabilities\n * - **Standardized semantics** - Values are registered in a central registry\n *\n * While Known Values are most commonly used as predicates in assertions, they\n * can appear in any position in an Envelope (subject, predicate, or object).\n *\n * @example\n * ```typescript\n * import { KnownValue } from '@bcts/known-values';\n *\n * // Create a Known Value with a numeric value\n * const knownValue = new KnownValue(42);\n * console.log(knownValue.value()); // 42\n *\n * // Create a Known Value with a name\n * const namedValue = new KnownValue(1, 'isA');\n * console.log(namedValue.value()); // 1\n * console.log(namedValue.name()); // \"isA\"\n *\n * // CBOR encoding\n * const cbor = namedValue.taggedCbor();\n * const bytes = namedValue.toCborData();\n *\n * // CBOR decoding\n * const decoded = KnownValue.fromTaggedCbor(cbor);\n * const decodedFromBytes = KnownValue.fromCborData(bytes);\n *\n * // Use a pre-defined Known Value from the registry\n * import { IS_A } from '@bcts/known-values';\n * console.log(IS_A.value()); // 1\n * console.log(IS_A.name()); // \"isA\"\n * ```\n *\n * @specification\n *\n * Known Values are defined in\n * [BCR-2023-002](https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2023-002-known-value.md)\n * and implemented as an Envelope extension in\n * [BCR-2023-003](https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2023-003-envelope-known-value.md).\n */\n\nimport {\n  type Cbor,\n  type Tag,\n  type CborTaggedEncodable,\n  type CborTaggedDecodable,\n  cbor,\n  cborData,\n  decodeCbor,\n  MajorType,\n} from \"@bcts/dcbor\";\nimport { KNOWN_VALUE } from \"@bcts/components\";\n\n/**\n * The numeric value for the CBOR tag used for Known Values.\n * This is Tag 40000 as defined in the Blockchain Commons registry.\n */\nexport const TAG_KNOWN_VALUE = KNOWN_VALUE.value;\n\n/**\n * The CBOR tag used for Known Values.\n * This is Tag 40000 as defined in the Blockchain Commons registry.\n */\nexport const KNOWN_VALUE_TAG: Tag = KNOWN_VALUE;\n\n/**\n * Type for values that can be used to create a KnownValue.\n * Supports both number (for values up to 2^53-1) and bigint (for full 64-bit range).\n */\nexport type KnownValueInput = number | bigint;\n\nexport class KnownValue implements CborTaggedEncodable, CborTaggedDecodable<KnownValue> {\n  private readonly _value: bigint;\n  private readonly _assignedName: string | undefined;\n\n  /**\n   * Creates a new KnownValue with the given numeric value and optional name.\n   *\n   * @param value - The numeric value (number or bigint). Numbers are converted to bigint internally.\n   * @param assignedName - Optional human-readable name for the value\n   *\n   * @example\n   * ```typescript\n   * const knownValue = new KnownValue(42);\n   * console.log(knownValue.value()); // 42\n   *\n   * const namedValue = new KnownValue(1, 'isA');\n   * console.log(namedValue.name()); // \"isA\"\n   *\n   * // Using bigint for large values\n   * const largeValue = new KnownValue(9007199254740993n);\n   * ```\n   */\n  constructor(value: KnownValueInput, assignedName?: string) {\n    this._value = typeof value === \"bigint\" ? value : BigInt(value);\n    this._assignedName = assignedName;\n  }\n\n  // ===========================================================================\n  // Value Accessors (backward compatible API)\n  // ===========================================================================\n\n  /**\n   * Returns the numeric value of the KnownValue.\n   *\n   * This is the raw unsigned integer that identifies the concept.\n   * Returns a number for backward compatibility. For values > MAX_SAFE_INTEGER,\n   * use `valueBigInt()`.\n   *\n   * @example\n   * ```typescript\n   * import { IS_A, NOTE } from '@bcts/known-values';\n   * console.log(IS_A.value()); // 1\n   * console.log(NOTE.value()); // 4\n   * ```\n   */\n  value(): number {\n    if (this._value > BigInt(Number.MAX_SAFE_INTEGER)) {\n      throw new RangeError(\n        `KnownValue ${this._value} exceeds MAX_SAFE_INTEGER. Use valueBigInt() instead.`,\n      );\n    }\n    return Number(this._value);\n  }\n\n  /**\n   * Returns the numeric value of the KnownValue as a bigint.\n   *\n   * Use this for values that may exceed Number.MAX_SAFE_INTEGER (2^53-1).\n   *\n   * @example\n   * ```typescript\n   * const largeValue = new KnownValue(9007199254740993n);\n   * console.log(largeValue.valueBigInt()); // 9007199254740993n\n   * ```\n   */\n  valueBigInt(): bigint {\n    return this._value;\n  }\n\n  /**\n   * Returns the assigned name of the KnownValue, if one exists.\n   *\n   * @example\n   * ```typescript\n   * const namedValue = new KnownValue(1, 'isA');\n   * console.log(namedValue.assignedName()); // \"isA\"\n   *\n   * const unnamedValue = new KnownValue(42);\n   * console.log(unnamedValue.assignedName()); // undefined\n   * ```\n   */\n  assignedName(): string | undefined {\n    return this._assignedName;\n  }\n\n  /**\n   * Returns a human-readable name for the KnownValue.\n   *\n   * If the KnownValue has an assigned name, that name is returned.\n   * Otherwise, the string representation of the numeric value is returned.\n   *\n   * @example\n   * ```typescript\n   * const namedValue = new KnownValue(1, 'isA');\n   * console.log(namedValue.name()); // \"isA\"\n   *\n   * const unnamedValue = new KnownValue(42);\n   * console.log(unnamedValue.name()); // \"42\"\n   * ```\n   */\n  name(): string {\n    return this._assignedName ?? this._value.toString();\n  }\n\n  // ===========================================================================\n  // Equality and Hashing\n  // ===========================================================================\n\n  /**\n   * Compares this KnownValue with another for equality.\n   * Equality is based solely on the numeric value, ignoring the name.\n   *\n   * @param other - The KnownValue to compare with\n   * @returns true if the values are equal\n   *\n   * @example\n   * ```typescript\n   * const kv1 = new KnownValue(1, 'isA');\n   * const kv2 = new KnownValue(1, 'different');\n   * console.log(kv1.equals(kv2)); // true (same value, different name)\n   * ```\n   */\n  equals(other: KnownValue): boolean {\n    return this._value === other._value;\n  }\n\n  /**\n   * Hash code based on the numeric value.\n   * Useful for using KnownValue in hash-based collections.\n   */\n  hashCode(): number {\n    // Convert bigint to a 32-bit hash\n    return Number(this._value & BigInt(0xffffffff));\n  }\n\n  /**\n   * String representation of the KnownValue.\n   *\n   * If a name is assigned, the name is displayed. Otherwise, the numeric value\n   * is displayed.\n   */\n  toString(): string {\n    return this.name();\n  }\n\n  // ===========================================================================\n  // CBOR Encoding (CborTaggedEncodable interface)\n  // ===========================================================================\n\n  /**\n   * Returns the CBOR tags associated with KnownValue.\n   *\n   * The primary tag is TAG_KNOWN_VALUE (201).\n   *\n   * @returns Array containing the KnownValue tag\n   */\n  cborTags(): Tag[] {\n    return [KNOWN_VALUE_TAG];\n  }\n\n  /**\n   * Returns the untagged CBOR encoding of this KnownValue.\n   *\n   * The untagged representation is simply the unsigned integer value.\n   *\n   * @returns CBOR representation of the value (unsigned integer)\n   */\n  untaggedCbor(): Cbor {\n    return cbor(this._value);\n  }\n\n  /**\n   * Returns the tagged CBOR encoding of this KnownValue.\n   *\n   * This wraps the unsigned integer value with tag 201.\n   *\n   * @returns Tagged CBOR representation\n   *\n   * @example\n   * ```typescript\n   * const kv = new KnownValue(1, 'isA');\n   * const tagged = kv.taggedCbor();\n   * console.log(tagged.toHex()); // \"d8c901\" (tag 201, value 1)\n   * ```\n   */\n  taggedCbor(): Cbor {\n    return cbor({\n      tag: TAG_KNOWN_VALUE,\n      value: this._value,\n    });\n  }\n\n  /**\n   * Returns the tagged CBOR encoding as binary data.\n   *\n   * @returns Binary CBOR representation\n   *\n   * @example\n   * ```typescript\n   * const kv = new KnownValue(1, 'isA');\n   * const bytes = kv.toCborData();\n   * // bytes is Uint8Array containing the CBOR encoding\n   * ```\n   */\n  toCborData(): Uint8Array {\n    return cborData(this.taggedCbor());\n  }\n\n  /**\n   * Alias for `toCborData()` to match the dcbor interface.\n   */\n  taggedCborData(): Uint8Array {\n    return this.toCborData();\n  }\n\n  // ===========================================================================\n  // CBOR Decoding (CborTaggedDecodable interface)\n  // ===========================================================================\n\n  /**\n   * Creates a KnownValue from untagged CBOR (an unsigned integer).\n   * Instance method for interface compliance.\n   *\n   * @param cborValue - The CBOR value (must be an unsigned integer)\n   * @returns A new KnownValue\n   * @throws {Error} If the CBOR is not an unsigned integer\n   */\n  fromUntaggedCbor(cborValue: Cbor): KnownValue {\n    return KnownValue.fromUntaggedCbor(cborValue);\n  }\n\n  /**\n   * Creates a KnownValue from tagged CBOR (tag 201).\n   * Instance method for interface compliance.\n   *\n   * @param cborValue - The tagged CBOR value\n   * @returns A new KnownValue\n   * @throws {Error} If the CBOR is not properly tagged or contains invalid data\n   */\n  fromTaggedCbor(cborValue: Cbor): KnownValue {\n    return KnownValue.fromTaggedCbor(cborValue);\n  }\n\n  // ===========================================================================\n  // Static Factory Methods\n  // ===========================================================================\n\n  /**\n   * Creates a KnownValue from untagged CBOR (an unsigned integer).\n   *\n   * @param cborValue - The CBOR value (must be an unsigned integer)\n   * @returns A new KnownValue\n   * @throws {Error} If the CBOR is not an unsigned integer\n   *\n   * @example\n   * ```typescript\n   * const cborValue = cbor(42);\n   * const kv = KnownValue.fromUntaggedCbor(cborValue);\n   * console.log(kv.value()); // 42\n   * ```\n   */\n  static fromUntaggedCbor(cborValue: Cbor): KnownValue {\n    if (cborValue.type !== MajorType.Unsigned) {\n      throw new Error(`Expected unsigned integer for KnownValue, got major type ${cborValue.type}`);\n    }\n    const numValue = cborValue.value as number | bigint;\n    return new KnownValue(typeof numValue === \"bigint\" ? numValue : BigInt(numValue));\n  }\n\n  /**\n   * Creates a KnownValue from tagged CBOR (tag 201).\n   *\n   * @param cborValue - The tagged CBOR value\n   * @returns A new KnownValue\n   * @throws {Error} If the CBOR is not properly tagged or contains invalid data\n   *\n   * @example\n   * ```typescript\n   * const kv = KnownValue.fromTaggedCbor(taggedCborValue);\n   * ```\n   */\n  static fromTaggedCbor(cborValue: Cbor): KnownValue {\n    if (cborValue.type !== MajorType.Tagged) {\n      throw new Error(`Expected tagged CBOR for KnownValue, got major type ${cborValue.type}`);\n    }\n\n    const tag = cborValue.tag;\n    if (tag !== BigInt(TAG_KNOWN_VALUE) && tag !== TAG_KNOWN_VALUE) {\n      throw new Error(`Expected tag ${TAG_KNOWN_VALUE} for KnownValue, got ${tag}`);\n    }\n\n    return KnownValue.fromUntaggedCbor(cborValue.value);\n  }\n\n  /**\n   * Creates a KnownValue from binary CBOR data.\n   *\n   * @param data - Binary CBOR data (must be a tagged KnownValue)\n   * @returns A new KnownValue\n   * @throws {Error} If the data cannot be decoded or is not a valid KnownValue\n   *\n   * @example\n   * ```typescript\n   * const bytes = new Uint8Array([0xd8, 0xc9, 0x01]); // tag 201, value 1\n   * const kv = KnownValue.fromCborData(bytes);\n   * console.log(kv.value()); // 1\n   * ```\n   */\n  static fromCborData(data: Uint8Array): KnownValue {\n    const cborValue = decodeCbor(data);\n    return KnownValue.fromTaggedCbor(cborValue);\n  }\n\n  /**\n   * Creates a KnownValue from a CBOR value, automatically detecting\n   * whether it's tagged or untagged.\n   *\n   * @param cborValue - The CBOR value (tagged or untagged)\n   * @returns A new KnownValue\n   * @throws {Error} If the CBOR cannot be converted to a KnownValue\n   *\n   * @example\n   * ```typescript\n   * // Works with both tagged and untagged\n   * const kv1 = KnownValue.fromCbor(cbor(42));\n   * const kv2 = KnownValue.fromCbor(taggedCborValue);\n   * ```\n   */\n  static fromCbor(cborValue: Cbor): KnownValue {\n    if (cborValue.type === MajorType.Tagged) {\n      return KnownValue.fromTaggedCbor(cborValue);\n    }\n    return KnownValue.fromUntaggedCbor(cborValue);\n  }\n}\n","import { KnownValue, type KnownValueInput } from \"./known-value\";\n\n/**\n * A store that maps between Known Values and their assigned names.\n *\n * The `KnownValuesStore` provides a bidirectional mapping between:\n * - Numeric values (bigint) and their corresponding KnownValue instances\n * - String names and their corresponding KnownValue instances\n *\n * This enables efficient lookup in both directions, making it possible to:\n * - Find the name for a given numeric value\n * - Find the numeric value for a given name\n * - Retrieve complete KnownValue instances by either name or value\n *\n * The store is typically populated with predefined Known Values from the\n * registry, but can also be extended with custom values.\n *\n * @example\n * ```typescript\n * import { KnownValuesStore, IS_A, NOTE, SIGNED } from '@bcts/known-values';\n *\n * // Create a store with predefined Known Values\n * const store = new KnownValuesStore([IS_A, NOTE, SIGNED]);\n *\n * // Look up a Known Value by name\n * const isA = store.knownValueNamed('isA');\n * console.log(isA?.value()); // 1\n *\n * // Look up a name for a raw value\n * const name = store.name(new KnownValue(3));\n * console.log(name); // \"signed\"\n *\n * // Insert a custom Known Value\n * const customStore = store.clone();\n * customStore.insert(new KnownValue(100, 'customValue'));\n * console.log(customStore.knownValueNamed('customValue')?.value()); // 100\n * ```\n */\nexport class KnownValuesStore {\n  // Use bigint for map keys to support full 64-bit range\n  private knownValuesByRawValue: Map<bigint, KnownValue>;\n  private knownValuesByAssignedName: Map<string, KnownValue>;\n\n  /**\n   * Creates a new KnownValuesStore with the provided Known Values.\n   *\n   * This constructor takes an iterable of KnownValue instances and\n   * populates the store with them, creating mappings from both raw\n   * values and names to the corresponding KnownValue instances.\n   *\n   * @param knownValues - Iterable of KnownValue instances to populate the store\n   *\n   * @example\n   * ```typescript\n   * import { KnownValuesStore, IS_A, NOTE, SIGNED } from '@bcts/known-values';\n   *\n   * // Create a store with predefined Known Values\n   * const store = new KnownValuesStore([IS_A, NOTE, SIGNED]);\n   *\n   * // Look up Known Values\n   * console.log(store.knownValueNamed('isA')?.value()); // 1\n   * console.log(store.knownValueNamed('note')?.value()); // 4\n   * ```\n   */\n  constructor(knownValues: Iterable<KnownValue> = []) {\n    this.knownValuesByRawValue = new Map();\n    this.knownValuesByAssignedName = new Map();\n\n    for (const knownValue of knownValues) {\n      this._insert(knownValue);\n    }\n  }\n\n  /**\n   * Inserts a KnownValue into the store.\n   *\n   * If the KnownValue has an assigned name, it will be indexed by both its\n   * raw value and its name. If a KnownValue with the same raw value or name\n   * already exists in the store, it will be replaced.\n   *\n   * @param knownValue - The KnownValue to insert\n   *\n   * @example\n   * ```typescript\n   * import { KnownValuesStore, KnownValue } from '@bcts/known-values';\n   *\n   * const store = new KnownValuesStore();\n   * store.insert(new KnownValue(100, 'customValue'));\n   * console.log(store.knownValueNamed('customValue')?.value()); // 100\n   * ```\n   */\n  insert(knownValue: KnownValue): void {\n    this._insert(knownValue);\n  }\n\n  /**\n   * Returns the assigned name for a KnownValue, if present in the store.\n   *\n   * @param knownValue - The KnownValue to look up\n   * @returns The assigned name, or undefined if not found\n   *\n   * @example\n   * ```typescript\n   * import { KnownValuesStore, IS_A } from '@bcts/known-values';\n   *\n   * const store = new KnownValuesStore([IS_A]);\n   * console.log(store.assignedName(IS_A)); // \"isA\"\n   * console.log(store.assignedName(new KnownValue(999))); // undefined\n   * ```\n   */\n  assignedName(knownValue: KnownValue): string | undefined {\n    return this.knownValuesByRawValue.get(knownValue.valueBigInt())?.assignedName();\n  }\n\n  /**\n   * Returns a human-readable name for a KnownValue.\n   *\n   * If the KnownValue has an assigned name in the store, that name is\n   * returned. Otherwise, the KnownValue's default name (which may be its\n   * numeric value as a string) is returned.\n   *\n   * @param knownValue - The KnownValue to get the name for\n   * @returns The name (assigned or numeric)\n   *\n   * @example\n   * ```typescript\n   * import { KnownValuesStore, IS_A } from '@bcts/known-values';\n   *\n   * const store = new KnownValuesStore([IS_A]);\n   * console.log(store.name(IS_A)); // \"isA\"\n   * console.log(store.name(new KnownValue(999))); // \"999\"\n   * ```\n   */\n  name(knownValue: KnownValue): string {\n    const assignedName = this.assignedName(knownValue);\n    return assignedName ?? knownValue.name();\n  }\n\n  /**\n   * Looks up a KnownValue by its assigned name.\n   *\n   * Returns the KnownValue if found, or undefined if no KnownValue\n   * with the given name exists in the store.\n   *\n   * @param assignedName - The name to look up\n   * @returns The KnownValue, or undefined if not found\n   *\n   * @example\n   * ```typescript\n   * import { KnownValuesStore, IS_A } from '@bcts/known-values';\n   *\n   * const store = new KnownValuesStore([IS_A]);\n   *\n   * const isA = store.knownValueNamed('isA');\n   * console.log(isA?.value()); // 1\n   *\n   * console.log(store.knownValueNamed('nonexistent')); // undefined\n   * ```\n   */\n  knownValueNamed(assignedName: string): KnownValue | undefined {\n    return this.knownValuesByAssignedName.get(assignedName);\n  }\n\n  /**\n   * Looks up a KnownValue by its raw numeric value.\n   *\n   * @param rawValue - The numeric value to look up (number or bigint)\n   * @returns The KnownValue, or undefined if not found\n   *\n   * @example\n   * ```typescript\n   * import { KnownValuesStore, IS_A } from '@bcts/known-values';\n   *\n   * const store = new KnownValuesStore([IS_A]);\n   * const isA = store.knownValueForValue(1);\n   * console.log(isA?.name()); // \"isA\"\n   * ```\n   */\n  knownValueForValue(rawValue: KnownValueInput): KnownValue | undefined {\n    const key = typeof rawValue === \"bigint\" ? rawValue : BigInt(rawValue);\n    return this.knownValuesByRawValue.get(key);\n  }\n\n  /**\n   * Retrieves a KnownValue for a raw value, using a store if provided.\n   *\n   * This static method allows looking up a KnownValue by its raw numeric\n   * value:\n   * - If a store is provided and contains a mapping for the raw value, that\n   *   KnownValue is returned\n   * - Otherwise, a new KnownValue with no assigned name is created and\n   *   returned\n   *\n   * @param rawValue - The numeric value to look up (number or bigint)\n   * @param knownValues - Optional store to search in\n   * @returns The KnownValue from the store or a new unnamed KnownValue\n   *\n   * @example\n   * ```typescript\n   * import { KnownValuesStore, IS_A } from '@bcts/known-values';\n   *\n   * const store = new KnownValuesStore([IS_A]);\n   *\n   * // Known value from store\n   * const isA = KnownValuesStore.knownValueForRawValue(1, store);\n   * console.log(isA.name()); // \"isA\"\n   *\n   * // Unknown value creates a new KnownValue\n   * const unknown = KnownValuesStore.knownValueForRawValue(999, store);\n   * console.log(unknown.name()); // \"999\"\n   *\n   * // No store provided also creates a new KnownValue\n   * const unknown2 = KnownValuesStore.knownValueForRawValue(1, undefined);\n   * console.log(unknown2.name()); // \"1\"\n   * ```\n   */\n  static knownValueForRawValue(\n    rawValue: KnownValueInput,\n    knownValues?: KnownValuesStore,\n  ): KnownValue {\n    if (knownValues !== undefined) {\n      const value = knownValues.knownValueForValue(rawValue);\n      if (value !== undefined) {\n        return value;\n      }\n    }\n    return new KnownValue(rawValue);\n  }\n\n  /**\n   * Attempts to find a KnownValue by its name, using a store if provided.\n   *\n   * This static method allows looking up a KnownValue by its name:\n   * - If a store is provided and contains a mapping for the name, that\n   *   KnownValue is returned\n   * - Otherwise, undefined is returned\n   *\n   * @param name - The name to look up\n   * @param knownValues - Optional store to search in\n   * @returns The KnownValue if found, or undefined\n   *\n   * @example\n   * ```typescript\n   * import { KnownValuesStore, IS_A } from '@bcts/known-values';\n   *\n   * const store = new KnownValuesStore([IS_A]);\n   *\n   * // Known value from store\n   * const isA = KnownValuesStore.knownValueForName('isA', store);\n   * console.log(isA?.value()); // 1\n   *\n   * // Unknown name returns undefined\n   * console.log(KnownValuesStore.knownValueForName('unknown', store)); // undefined\n   *\n   * // No store provided also returns undefined\n   * console.log(KnownValuesStore.knownValueForName('isA', undefined)); // undefined\n   * ```\n   */\n  static knownValueForName(name: string, knownValues?: KnownValuesStore): KnownValue | undefined {\n    return knownValues?.knownValueNamed(name);\n  }\n\n  /**\n   * Returns a human-readable name for a KnownValue, using a store if provided.\n   *\n   * This static method allows getting a name for a KnownValue:\n   * - If a store is provided and contains a mapping for the KnownValue, its\n   *   assigned name is returned\n   * - Otherwise, the KnownValue's default name (which may be its numeric\n   *   value as a string) is returned\n   *\n   * @param knownValue - The KnownValue to get the name for\n   * @param knownValues - Optional store to use for lookup\n   * @returns The name (assigned or numeric)\n   *\n   * @example\n   * ```typescript\n   * import { KnownValuesStore, IS_A } from '@bcts/known-values';\n   *\n   * const store = new KnownValuesStore([IS_A]);\n   *\n   * // Known value from store\n   * let name = KnownValuesStore.nameForKnownValue(IS_A, store);\n   * console.log(name); // \"isA\"\n   *\n   * // Unknown value in store uses KnownValue's name method\n   * name = KnownValuesStore.nameForKnownValue(new KnownValue(999), store);\n   * console.log(name); // \"999\"\n   *\n   * // No store provided also uses KnownValue's name method\n   * name = KnownValuesStore.nameForKnownValue(IS_A, undefined);\n   * console.log(name); // \"isA\"\n   * ```\n   */\n  static nameForKnownValue(knownValue: KnownValue, knownValues?: KnownValuesStore): string {\n    if (knownValues !== undefined) {\n      const assignedName = knownValues.assignedName(knownValue);\n      if (assignedName !== undefined && assignedName !== \"\") {\n        return assignedName;\n      }\n    }\n    return knownValue.name();\n  }\n\n  /**\n   * Creates a shallow clone of this store.\n   *\n   * @returns A new KnownValuesStore with the same entries\n   */\n  clone(): KnownValuesStore {\n    const cloned = new KnownValuesStore();\n    cloned.knownValuesByRawValue = new Map(this.knownValuesByRawValue);\n    cloned.knownValuesByAssignedName = new Map(this.knownValuesByAssignedName);\n    return cloned;\n  }\n\n  /**\n   * Internal helper method to insert a KnownValue into the store's maps.\n   */\n  private _insert(knownValue: KnownValue): void {\n    this.knownValuesByRawValue.set(knownValue.valueBigInt(), knownValue);\n    const assignedName = knownValue.assignedName();\n    if (assignedName !== undefined && assignedName !== \"\") {\n      this.knownValuesByAssignedName.set(assignedName, knownValue);\n    }\n  }\n}\n","import { KnownValue } from \"./known-value\";\nimport { KnownValuesStore } from \"./known-values-store\";\n\n// For definitions see: https://github.com/BlockchainCommons/Research/blob/master/papers/bcr-2023-002-known-value.md#appendix-a-registry\n\n//\n// General\n//\n\nexport const UNIT = new KnownValue(0, \"\");\nexport const IS_A = new KnownValue(1, \"isA\");\nexport const ID = new KnownValue(2, \"id\");\nexport const SIGNED = new KnownValue(3, \"signed\");\nexport const NOTE = new KnownValue(4, \"note\");\nexport const HAS_RECIPIENT = new KnownValue(5, \"hasRecipient\");\nexport const SSKR_SHARE = new KnownValue(6, \"sskrShare\");\nexport const CONTROLLER = new KnownValue(7, \"controller\");\nexport const KEY = new KnownValue(8, \"key\");\nexport const DEREFERENCE_VIA = new KnownValue(9, \"dereferenceVia\");\nexport const ENTITY = new KnownValue(10, \"entity\");\nexport const NAME = new KnownValue(11, \"name\");\nexport const LANGUAGE = new KnownValue(12, \"language\");\nexport const ISSUER = new KnownValue(13, \"issuer\");\nexport const HOLDER = new KnownValue(14, \"holder\");\nexport const SALT = new KnownValue(15, \"salt\");\nexport const DATE = new KnownValue(16, \"date\");\nexport const UNKNOWN_VALUE = new KnownValue(17, \"Unknown\");\nexport const VERSION_VALUE = new KnownValue(18, \"version\");\nexport const HAS_SECRET = new KnownValue(19, \"hasSecret\");\nexport const DIFF_EDITS = new KnownValue(20, \"edits\");\nexport const VALID_FROM = new KnownValue(21, \"validFrom\");\nexport const VALID_UNTIL = new KnownValue(22, \"validUntil\");\nexport const POSITION = new KnownValue(23, \"position\");\nexport const NICKNAME = new KnownValue(24, \"nickname\");\n// 25-49 *unassigned*\n\n//\n// Attachments\n//\n\nexport const ATTACHMENT = new KnownValue(50, \"attachment\");\nexport const VENDOR = new KnownValue(51, \"vendor\");\nexport const CONFORMS_TO = new KnownValue(52, \"conformsTo\");\n// 53-59 *unassigned*\n\n//\n// XID Documents\n//\n\nexport const ALLOW = new KnownValue(60, \"allow\");\nexport const DENY = new KnownValue(61, \"deny\");\nexport const ENDPOINT = new KnownValue(62, \"endpoint\");\nexport const DELEGATE = new KnownValue(63, \"delegate\");\nexport const PROVENANCE = new KnownValue(64, \"provenance\");\nexport const PRIVATE_KEY = new KnownValue(65, \"privateKey\");\nexport const SERVICE = new KnownValue(66, \"service\");\nexport const CAPABILITY = new KnownValue(67, \"capability\");\nexport const PROVENANCE_GENERATOR = new KnownValue(68, \"provenanceGenerator\");\n// 68-69 *unassigned*\n\n//\n// XID Privileges\n//\n\nexport const PRIVILEGE_ALL = new KnownValue(70, \"All\");\nexport const PRIVILEGE_AUTH = new KnownValue(71, \"Auth\");\nexport const PRIVILEGE_SIGN = new KnownValue(72, \"Sign\");\nexport const PRIVILEGE_ENCRYPT = new KnownValue(73, \"Encrypt\");\nexport const PRIVILEGE_ELIDE = new KnownValue(74, \"Elide\");\nexport const PRIVILEGE_ISSUE = new KnownValue(75, \"Issue\");\nexport const PRIVILEGE_ACCESS = new KnownValue(76, \"Access\");\n// 77-79 *unassigned*\nexport const PRIVILEGE_DELEGATE = new KnownValue(80, \"Delegate\");\nexport const PRIVILEGE_VERIFY = new KnownValue(81, \"Verify\");\nexport const PRIVILEGE_UPDATE = new KnownValue(82, \"Update\");\nexport const PRIVILEGE_TRANSFER = new KnownValue(83, \"Transfer\");\nexport const PRIVILEGE_ELECT = new KnownValue(84, \"Elect\");\nexport const PRIVILEGE_BURN = new KnownValue(85, \"Burn\");\nexport const PRIVILEGE_REVOKE = new KnownValue(86, \"Revoke\");\n// 87-99 *unassigned*\n\n//\n// Expression and Function Calls\n//\n\nexport const BODY = new KnownValue(100, \"body\");\nexport const RESULT = new KnownValue(101, \"result\");\nexport const ERROR = new KnownValue(102, \"error\");\nexport const OK_VALUE = new KnownValue(103, \"OK\");\nexport const PROCESSING_VALUE = new KnownValue(104, \"Processing\");\nexport const SENDER = new KnownValue(105, \"sender\");\nexport const SENDER_CONTINUATION = new KnownValue(106, \"senderContinuation\");\nexport const RECIPIENT_CONTINUATION = new KnownValue(107, \"recipientContinuation\");\nexport const CONTENT = new KnownValue(108, \"content\");\n// 109-199 *unassigned*\n\n//\n// Cryptography\n//\n\nexport const SEED_TYPE = new KnownValue(200, \"Seed\");\nexport const PRIVATE_KEY_TYPE = new KnownValue(201, \"PrivateKey\");\nexport const PUBLIC_KEY_TYPE = new KnownValue(202, \"PublicKey\");\nexport const MASTER_KEY_TYPE = new KnownValue(203, \"MasterKey\");\n// 204-299 *unassigned*\n\n//\n// Cryptocurrency Assets\n//\n\nexport const ASSET = new KnownValue(300, \"asset\");\nexport const BITCOIN_VALUE = new KnownValue(301, \"BTC\");\nexport const ETHEREUM_VALUE = new KnownValue(302, \"ETH\");\nexport const TEZOS_VALUE = new KnownValue(303, \"XTZ\");\n// 304-399 *unassigned*\n\n//\n// Cryptocurrency Networks\n//\n\nexport const NETWORK = new KnownValue(400, \"network\");\nexport const MAIN_NET_VALUE = new KnownValue(401, \"MainNet\");\nexport const TEST_NET_VALUE = new KnownValue(402, \"TestNet\");\n// 403-499 *unassigned*\n\n//\n// Bitcoin\n//\n\nexport const BIP32_KEY_TYPE = new KnownValue(500, \"BIP32Key\");\nexport const CHAIN_CODE = new KnownValue(501, \"chainCode\");\nexport const DERIVATION_PATH_TYPE = new KnownValue(502, \"DerivationPath\");\nexport const PARENT_PATH = new KnownValue(503, \"parent\");\nexport const CHILDREN_PATH = new KnownValue(504, \"children\");\nexport const PARENT_FINGERPRINT = new KnownValue(505, \"parentFingerprint\");\nexport const PSBT_TYPE = new KnownValue(506, \"PSBT\");\nexport const OUTPUT_DESCRIPTOR_TYPE = new KnownValue(507, \"OutputDescriptor\");\nexport const OUTPUT_DESCRIPTOR = new KnownValue(508, \"outputDescriptor\");\n// 509-599 *unassigned*\n\n//\n// Graphs\n//\n\nexport const GRAPH = new KnownValue(600, \"graph\");\nexport const SOURCE_TARGET_GRAPH = new KnownValue(601, \"SourceTargetGraph\");\nexport const PARENT_CHILD_GRAPH = new KnownValue(602, \"ParentChildGraph\");\nexport const DIGRAPH = new KnownValue(603, \"Digraph\");\nexport const ACYCLIC_GRAPH = new KnownValue(604, \"AcyclicGraph\");\nexport const MULTIGRAPH = new KnownValue(605, \"Multigraph\");\nexport const PSEUDOGRAPH = new KnownValue(606, \"Pseudograph\");\nexport const GRAPH_FRAGMENT = new KnownValue(607, \"GraphFragment\");\nexport const DAG = new KnownValue(608, \"DAG\");\nexport const TREE = new KnownValue(609, \"Tree\");\nexport const FOREST = new KnownValue(610, \"Forest\");\nexport const COMPOUND_GRAPH = new KnownValue(611, \"CompoundGraph\");\nexport const HYPERGRAPH = new KnownValue(612, \"Hypergraph\");\nexport const DIHYPERGRAPH = new KnownValue(613, \"Dihypergraph\");\n// 614-699 *unassigned*\nexport const NODE = new KnownValue(700, \"node\");\nexport const EDGE = new KnownValue(701, \"edge\");\nexport const SOURCE = new KnownValue(702, \"source\");\nexport const TARGET = new KnownValue(703, \"target\");\nexport const PARENT = new KnownValue(704, \"parent\");\nexport const CHILD = new KnownValue(705, \"child\");\n// 706-... *unassigned*\n\n/**\n * A lazily initialized singleton that holds the global registry of known\n * values.\n *\n * This class provides thread-safe, lazy initialization of the global\n * KnownValuesStore that contains all the predefined Known Values in the\n * registry. The store is created only when first accessed, and subsequent\n * accesses reuse the same instance.\n *\n * This is used internally by the crate and should not typically be needed by\n * users of the API, who should access Known Values through the constants\n * exposed in the `known_values` module.\n */\nexport class LazyKnownValues {\n  private _data: KnownValuesStore | undefined;\n\n  /**\n   * Gets the global KnownValuesStore, initializing it if necessary.\n   *\n   * This method guarantees that initialization occurs exactly once.\n   */\n  get(): KnownValuesStore {\n    this._data ??= new KnownValuesStore([\n      UNIT,\n      IS_A,\n      ID,\n      SIGNED,\n      NOTE,\n      HAS_RECIPIENT,\n      SSKR_SHARE,\n      CONTROLLER,\n      KEY,\n      DEREFERENCE_VIA,\n      ENTITY,\n      NAME,\n      LANGUAGE,\n      ISSUER,\n      HOLDER,\n      SALT,\n      DATE,\n      UNKNOWN_VALUE,\n      VERSION_VALUE,\n      HAS_SECRET,\n      DIFF_EDITS,\n      VALID_FROM,\n      VALID_UNTIL,\n      POSITION,\n      NICKNAME,\n      ATTACHMENT,\n      VENDOR,\n      CONFORMS_TO,\n      ALLOW,\n      DENY,\n      ENDPOINT,\n      DELEGATE,\n      PROVENANCE,\n      PRIVATE_KEY,\n      SERVICE,\n      CAPABILITY,\n      PROVENANCE_GENERATOR,\n      PRIVILEGE_ALL,\n      PRIVILEGE_AUTH,\n      PRIVILEGE_SIGN,\n      PRIVILEGE_ENCRYPT,\n      PRIVILEGE_ELIDE,\n      PRIVILEGE_ISSUE,\n      PRIVILEGE_ACCESS,\n      PRIVILEGE_DELEGATE,\n      PRIVILEGE_VERIFY,\n      PRIVILEGE_UPDATE,\n      PRIVILEGE_TRANSFER,\n      PRIVILEGE_ELECT,\n      PRIVILEGE_BURN,\n      PRIVILEGE_REVOKE,\n      BODY,\n      RESULT,\n      ERROR,\n      OK_VALUE,\n      PROCESSING_VALUE,\n      SENDER,\n      SENDER_CONTINUATION,\n      RECIPIENT_CONTINUATION,\n      CONTENT,\n      SEED_TYPE,\n      PRIVATE_KEY_TYPE,\n      PUBLIC_KEY_TYPE,\n      MASTER_KEY_TYPE,\n      ASSET,\n      BITCOIN_VALUE,\n      ETHEREUM_VALUE,\n      TEZOS_VALUE,\n      NETWORK,\n      MAIN_NET_VALUE,\n      TEST_NET_VALUE,\n      BIP32_KEY_TYPE,\n      CHAIN_CODE,\n      DERIVATION_PATH_TYPE,\n      PARENT_PATH,\n      CHILDREN_PATH,\n      PARENT_FINGERPRINT,\n      PSBT_TYPE,\n      OUTPUT_DESCRIPTOR_TYPE,\n      OUTPUT_DESCRIPTOR,\n      GRAPH,\n      SOURCE_TARGET_GRAPH,\n      PARENT_CHILD_GRAPH,\n      DIGRAPH,\n      ACYCLIC_GRAPH,\n      MULTIGRAPH,\n      PSEUDOGRAPH,\n      GRAPH_FRAGMENT,\n      DAG,\n      TREE,\n      FOREST,\n      COMPOUND_GRAPH,\n      HYPERGRAPH,\n      DIHYPERGRAPH,\n      NODE,\n      EDGE,\n      SOURCE,\n      TARGET,\n      PARENT,\n      CHILD,\n    ]);\n    return this._data;\n  }\n}\n\n/**\n * The global registry of Known Values.\n *\n * This static instance provides access to all standard Known Values defined in\n * the registry specification. It is lazily initialized on first access.\n *\n * Most users should not need to interact with this directly, as the predefined\n * Known Values are exposed as constants in the `known_values` module.\n *\n * @example\n * ```typescript\n * import { KNOWN_VALUES } from '@bcts/known-values';\n *\n * // Access the global store\n * const knownValues = KNOWN_VALUES.get();\n *\n * // Look up a Known Value by name\n * const isA = knownValues.knownValueNamed('isA');\n * console.log(isA?.value()); // 1\n * ```\n */\nexport const KNOWN_VALUES = new LazyKnownValues();\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "@bcts/known-values",
+  "version": "1.0.0-alpha.10",
+  "type": "module",
+  "description": "Blockchain Commons Known Values for TypeScript",
+  "license": "BSD-2-Clause-Patent",
+  "author": "Leonardo Custodio <leonardo@custodio.me>",
+  "homepage": "https://bcts.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/leonardocustodio/bcts",
+    "directory": "packages/known-values"
+  },
+  "bugs": {
+    "url": "https://github.com/leonardocustodio/bcts/issues"
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.mts",
+  "browser": "dist/index.iife.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "lint": "eslint 'src/**/*.ts'",
+    "lint:fix": "eslint 'src/**/*.ts' --fix",
+    "typecheck": "tsc --noEmit",
+    "docs": "typedoc"
+  },
+  "keywords": [
+    "known-values",
+    "blockchain-commons",
+    "ontology",
+    "encoding",
+    "cbor",
+    "dcbor",
+    "deterministic"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "@bcts/components": "^1.0.0-alpha.10",
+    "@bcts/dcbor": "^1.0.0-alpha.10"
+  },
+  "devDependencies": {
+    "@bcts/eslint": "^0.1.0",
+    "@bcts/tsconfig": "^0.1.0",
+    "@eslint/js": "^9.39.2",
+    "@types/node": "^25.0.3",
+    "@types/pako": "^2.0.4",
+    "eslint": "^9.39.2",
+    "prettier": "^3.7.4",
+    "ts-node": "^10.9.2",
+    "tsdown": "^0.18.3",
+    "typedoc": "^0.28.15",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
+  }
+}

package/src/index.ts

@@ -0,0 +1,116 @@
+export { KnownValue, TAG_KNOWN_VALUE, KNOWN_VALUE_TAG, type KnownValueInput } from "./known-value";
+export { KnownValuesStore } from "./known-values-store";
+export {
+  // General
+  UNIT,
+  IS_A,
+  ID,
+  SIGNED,
+  NOTE,
+  HAS_RECIPIENT,
+  SSKR_SHARE,
+  CONTROLLER,
+  KEY,
+  DEREFERENCE_VIA,
+  ENTITY,
+  NAME,
+  LANGUAGE,
+  ISSUER,
+  HOLDER,
+  SALT,
+  DATE,
+  UNKNOWN_VALUE,
+  VERSION_VALUE,
+  HAS_SECRET,
+  DIFF_EDITS,
+  VALID_FROM,
+  VALID_UNTIL,
+  POSITION,
+  NICKNAME,
+  // Attachments
+  ATTACHMENT,
+  VENDOR,
+  CONFORMS_TO,
+  // XID Documents
+  ALLOW,
+  DENY,
+  ENDPOINT,
+  DELEGATE,
+  PROVENANCE,
+  PRIVATE_KEY,
+  SERVICE,
+  CAPABILITY,
+  PROVENANCE_GENERATOR,
+  // XID Privileges
+  PRIVILEGE_ALL,
+  PRIVILEGE_AUTH,
+  PRIVILEGE_SIGN,
+  PRIVILEGE_ENCRYPT,
+  PRIVILEGE_ELIDE,
+  PRIVILEGE_ISSUE,
+  PRIVILEGE_ACCESS,
+  PRIVILEGE_DELEGATE,
+  PRIVILEGE_VERIFY,
+  PRIVILEGE_UPDATE,
+  PRIVILEGE_TRANSFER,
+  PRIVILEGE_ELECT,
+  PRIVILEGE_BURN,
+  PRIVILEGE_REVOKE,
+  // Expression and Function Calls
+  BODY,
+  RESULT,
+  ERROR,
+  OK_VALUE,
+  PROCESSING_VALUE,
+  SENDER,
+  SENDER_CONTINUATION,
+  RECIPIENT_CONTINUATION,
+  CONTENT,
+  // Cryptography
+  SEED_TYPE,
+  PRIVATE_KEY_TYPE,
+  PUBLIC_KEY_TYPE,
+  MASTER_KEY_TYPE,
+  // Cryptocurrency Assets
+  ASSET,
+  BITCOIN_VALUE,
+  ETHEREUM_VALUE,
+  TEZOS_VALUE,
+  // Cryptocurrency Networks
+  NETWORK,
+  MAIN_NET_VALUE,
+  TEST_NET_VALUE,
+  // Bitcoin
+  BIP32_KEY_TYPE,
+  CHAIN_CODE,
+  DERIVATION_PATH_TYPE,
+  PARENT_PATH,
+  CHILDREN_PATH,
+  PARENT_FINGERPRINT,
+  PSBT_TYPE,
+  OUTPUT_DESCRIPTOR_TYPE,
+  OUTPUT_DESCRIPTOR,
+  // Graphs
+  GRAPH,
+  SOURCE_TARGET_GRAPH,
+  PARENT_CHILD_GRAPH,
+  DIGRAPH,
+  ACYCLIC_GRAPH,
+  MULTIGRAPH,
+  PSEUDOGRAPH,
+  GRAPH_FRAGMENT,
+  DAG,
+  TREE,
+  FOREST,
+  COMPOUND_GRAPH,
+  HYPERGRAPH,
+  DIHYPERGRAPH,
+  NODE,
+  EDGE,
+  SOURCE,
+  TARGET,
+  PARENT,
+  CHILD,
+  KNOWN_VALUES,
+  LazyKnownValues,
+} from "./known-values-registry";