@homaiohq/napi-quickfix 0.0.0-stage → 0.2.0

package/dist/cjs/enums.d.ts

@@ -0,0 +1,56 @@
+/**
+ * FIX constants.
+ *
+ * - {@link FIELD} — field-name → tag-number (e.g. `FIELD.MsgType === 35`).
+ *   Generated from QuickFIX's `FixFieldNumbers.h` (see `src/generated/fields.ts`),
+ *   so it carries every `FIX::FIELD::*` name the bundled engine knows.
+ * - value groups such as {@link MsgType} and {@link Side} (e.g.
+ *   `MsgType.Logon === 'A'`, `Side.Buy === '1'`) — one per field, generated from
+ *   QuickFIX's `FixValues.h` (see `src/generated/values.ts`), so every
+ *   `FIX::<Field>_<VALUE>` constant is here. {@link VALUES} holds all of them
+ *   keyed by field name, and each group is also importable from
+ *   `@homaiohq/napi-quickfix/values` without loading the native addon.
+ *
+ * Everything carries literal types and is frozen, so a misspelt name is a
+ * compile error and consumers cannot mutate the shared constant tables.
+ *
+ * @example
+ * ```ts
+ * import { FIELD, MsgType, enums } from '@homaiohq/napi-quickfix';
+ * msg.setField(FIELD.MsgType, MsgType.Logon);
+ * const side = enums.Side.Buy;
+ * ```
+ */
+import { FIELD } from './generated/fields.js';
+import { type ValueGroups } from './generated/values.js';
+export { FIELD, type FieldName } from './generated/fields.js';
+export { VALUES, MsgType, Side, OrdType, TimeInForce, type ValueGroups, type ValueGroupName, } from './generated/values.js';
+/**
+ * A single group of FIX constants widened to a string-indexed map (name → value).
+ *
+ * Every value group and {@link FIELD} is assignable to it, so use it where a group
+ * is looked up by a `string` key the compiler cannot narrow (a name read from
+ * configuration, say) instead of the literally-typed group itself:
+ *
+ * @example
+ * ```ts
+ * const group: EnumGroup = enums[name as ValueGroupName];
+ * const code = group[valueName];
+ * ```
+ */
+export type EnumGroup = Readonly<Record<string, number | string>>;
+/**
+ * The full, frozen tree of FIX constants: every value group of {@link ValueGroups}
+ * plus the {@link FIELD} tag table.
+ */
+export type Enums = ValueGroups & {
+    readonly FIELD: typeof FIELD;
+};
+/**
+ * The complete tree of FIX constants (frozen), e.g. `enums.FIELD.MsgType`,
+ * `enums.MsgType.Logon`, `enums.Side.Buy`.
+ *
+ * `enums.FIELD` is the same table as {@link FIELD}; every other member is the
+ * same object as the corresponding {@link VALUES} group.
+ */
+export declare const enums: Enums;

package/dist/cjs/enums.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enums = exports.TimeInForce = exports.OrdType = exports.Side = exports.MsgType = exports.VALUES = exports.FIELD = void 0;
+/**
+ * FIX constants.
+ *
+ * - {@link FIELD} — field-name → tag-number (e.g. `FIELD.MsgType === 35`).
+ *   Generated from QuickFIX's `FixFieldNumbers.h` (see `src/generated/fields.ts`),
+ *   so it carries every `FIX::FIELD::*` name the bundled engine knows.
+ * - value groups such as {@link MsgType} and {@link Side} (e.g.
+ *   `MsgType.Logon === 'A'`, `Side.Buy === '1'`) — one per field, generated from
+ *   QuickFIX's `FixValues.h` (see `src/generated/values.ts`), so every
+ *   `FIX::<Field>_<VALUE>` constant is here. {@link VALUES} holds all of them
+ *   keyed by field name, and each group is also importable from
+ *   `@homaiohq/napi-quickfix/values` without loading the native addon.
+ *
+ * Everything carries literal types and is frozen, so a misspelt name is a
+ * compile error and consumers cannot mutate the shared constant tables.
+ *
+ * @example
+ * ```ts
+ * import { FIELD, MsgType, enums } from '@homaiohq/napi-quickfix';
+ * msg.setField(FIELD.MsgType, MsgType.Logon);
+ * const side = enums.Side.Buy;
+ * ```
+ */
+const fields_js_1 = require("./generated/fields.js");
+const values_js_1 = require("./generated/values.js");
+var fields_js_2 = require("./generated/fields.js");
+Object.defineProperty(exports, "FIELD", { enumerable: true, get: function () { return fields_js_2.FIELD; } });
+var values_js_2 = require("./generated/values.js");
+Object.defineProperty(exports, "VALUES", { enumerable: true, get: function () { return values_js_2.VALUES; } });
+Object.defineProperty(exports, "MsgType", { enumerable: true, get: function () { return values_js_2.MsgType; } });
+Object.defineProperty(exports, "Side", { enumerable: true, get: function () { return values_js_2.Side; } });
+Object.defineProperty(exports, "OrdType", { enumerable: true, get: function () { return values_js_2.OrdType; } });
+Object.defineProperty(exports, "TimeInForce", { enumerable: true, get: function () { return values_js_2.TimeInForce; } });
+/**
+ * The complete tree of FIX constants (frozen), e.g. `enums.FIELD.MsgType`,
+ * `enums.MsgType.Logon`, `enums.Side.Buy`.
+ *
+ * `enums.FIELD` is the same table as {@link FIELD}; every other member is the
+ * same object as the corresponding {@link VALUES} group.
+ */
+exports.enums = Object.freeze({ ...values_js_1.VALUES, FIELD: fields_js_1.FIELD });

package/dist/cjs/field-value.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Wire formatting of the `string | number` field values `Message` and `Group`
+ * accept.
+ */
+/**
+ * A field value as FIX text. Strings pass through. A number keeps its shortest
+ * round-trip digits but is written without exponent notation, which FIX numeric
+ * fields do not allow (`1e-7` → `'0.0000001'`, `1e21` →
+ * `'1000000000000000000000'`, where `String` gives `'1e-7'` and `'1e+21'`).
+ * @throws `RangeError` for `NaN` and `±Infinity`, which have no FIX form.
+ */
+export declare function formatFieldValue(value: string | number): string;

package/dist/cjs/field-value.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Wire formatting of the `string | number` field values `Message` and `Group`
+ * accept.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatFieldValue = formatFieldValue;
+/**
+ * A field value as FIX text. Strings pass through. A number keeps its shortest
+ * round-trip digits but is written without exponent notation, which FIX numeric
+ * fields do not allow (`1e-7` → `'0.0000001'`, `1e21` →
+ * `'1000000000000000000000'`, where `String` gives `'1e-7'` and `'1e+21'`).
+ * @throws `RangeError` for `NaN` and `±Infinity`, which have no FIX form.
+ */
+function formatFieldValue(value) {
+    if (typeof value !== 'number') {
+        return String(value);
+    }
+    if (!Number.isFinite(value)) {
+        throw new RangeError(`field value must be a finite number, got ${value}`);
+    }
+    const text = String(value);
+    const e = text.indexOf('e');
+    if (e === -1) {
+        return text;
+    }
+    // `[-]d[.ddd]e±n`: move the decimal point of the mantissa n places.
+    const sign = value < 0 ? '-' : '';
+    const mantissa = text.slice(sign.length, e);
+    const point = mantissa.indexOf('.');
+    const digits = mantissa.replace('.', '');
+    const at = (point === -1 ? mantissa.length : point) + Number(text.slice(e + 1));
+    if (at <= 0) {
+        return `${sign}0.${'0'.repeat(-at)}${digits}`;
+    }
+    if (at >= digits.length) {
+        return `${sign}${digits}${'0'.repeat(at - digits.length)}`;
+    }
+    return `${sign}${digits.slice(0, at)}.${digits.slice(at)}`;
+}