@asod/field 0.1.0-canary.1 → 0.1.0-canary.2

package/dist/core.d.ts

@@ -0,0 +1,39 @@
+import ASOD from '@asod/core';
+
+declare module '@asod/core' {
+  namespace Operation {
+    interface IComparable {
+      comparator?: ASOD.Comparator;
+    }
+
+    interface IOperationObjectValue extends IComparable {}
+
+    type OperationValue = Primitive | IOperationObjectValue;
+
+    interface IOperation<TValue extends OperationValue> {
+      (...values: [TValue, ...TValue[]]): TValue;
+    }
+
+    interface IBinaryOperation<TValue extends OperationValue>
+      extends IOperation<TValue> {
+      (a: TValue, b: TValue): TValue;
+    }
+  }
+
+  namespace Ring {
+    interface IRing<TValue extends OperationValue> {
+      add: IOperation<TValue>;
+      mul: IOperation<TValue>;
+    }
+  }
+
+  namespace Field {
+    interface IField<TValue extends OperationValue> extends IRing<TValue> {
+      sub: IOperation<TValue>;
+      div: IOperation<TValue>;
+    }
+  }
+}
+
+export = ASOD;
+export as namespace ASOD;

package/dist/field.d.ts

@@ -1,25 +1,23 @@
-import { type Field } from './declarations/index';
-type FieldOperationConfig<TValue extends Field.OperationValue> = {
-    func: Field.IOperation<TValue>;
+import type ASOD from './core';
+import { Ring } from './ring';
+type FieldOperationConfig<TValue extends ASOD.Operation.OperationValue> = {
+    func: ASOD.Operation.IBinaryOperation<TValue>;
     neutralValue: TValue;
 };
-type FieldOperationsConfig<TValue extends Field.OperationValue> = {
+type FieldOperationsConfig<TValue extends ASOD.Operation.OperationValue> = {
     add: FieldOperationConfig<TValue>;
     sub: FieldOperationConfig<TValue>;
     mul: FieldOperationConfig<TValue>;
     div: FieldOperationConfig<TValue>;
 };
-type FieldConfig<TValue extends Field.OperationValue> = {
+type FieldConfig<TValue extends ASOD.Operation.OperationValue> = {
     operations: FieldOperationsConfig<TValue>;
 };
-declare class Field<TValue extends Field.OperationValue> implements Field.IField<TValue> {
-    private readonly _operations;
+declare class Field<TValue extends ASOD.Operation.OperationValue> extends Ring<TValue> implements ASOD.Field.IField<TValue> {
+    protected readonly _operations: Readonly<FieldOperationsConfig<TValue>>;
     constructor(config: FieldConfig<TValue>);
-    add(a: TValue, b: TValue): TValue;
     sub(a: TValue, b: TValue): TValue;
-    mul(a: TValue, b: TValue): TValue;
     div(a: TValue, b: TValue): TValue;
-    private _compare;
 }
 export { Field };
 export default Field;

package/dist/field.js

@@ -16,8 +16,7 @@ _export(exports, {
         return _default;
     }
 });
-const _compare = require("@asod/compare");
-const _guards = require("./utils/guards");
+const _ring = require("./ring");
 function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
@@ -31,36 +30,19 @@ function _define_property(obj, key, value) {
     }
     return obj;
 }
-class Field {
-    add(a, b) {
-        const { func, neutralValue } = this._operations.add;
-        if (!this._compare(a, neutralValue)) return b;
-        if (!this._compare(b, neutralValue)) return a;
-        return func(a, b);
-    }
+class Field extends _ring.Ring {
     sub(a, b) {
         const { func, neutralValue } = this._operations.sub;
         if (!this._compare(b, neutralValue)) return a;
         return func(a, b);
     }
-    mul(a, b) {
-        const { func, neutralValue } = this._operations.mul;
-        if (!this._compare(a, neutralValue)) return b;
-        if (!this._compare(b, neutralValue)) return a;
-        return func(a, b);
-    }
     div(a, b) {
         const { func, neutralValue } = this._operations.div;
         if (!this._compare(b, neutralValue)) return a;
         return func(a, b);
     }
-    _compare(a, b) {
-        if ((0, _guards.isComparable)(a)) return (0, _compare.compare)(a, b, a.comparator);
-        if ((0, _guards.isComparable)(b)) return (0, _compare.compare)(a, b, b.comparator);
-        return (0, _compare.compare)(a, b);
-    }
     constructor(config){
-        _define_property(this, "_operations", void 0);
+        super(config), _define_property(this, "_operations", void 0);
         this._operations = config.operations;
     }
 }

package/dist/index.d.ts

@@ -1,53 +1,2 @@
-/// <reference path="global.d.ts" />
-
-import ASOD from '@asod/core';
-import { type Comparator } from '@asod/compare';
-
-declare const ABSTRACT_OPERATION_ID: unique symbol;
-
-type AbstractOperationId = typeof ABSTRACT_OPERATION_ID;
-
-declare module '@asod/core' {
-  namespace Field {
-    /* Common */
-
-    interface IComparable {
-      comparator?: Comparator;
-    }
-
-    /* Operation */
-
-    interface IOperationValue extends IComparable {}
-
-    type OperationValue = Primitive | IOperationValue;
-
-    interface IOperation<TValue extends OperationValue> {
-      (a: TValue, b: TValue): TValue;
-    }
-
-    /* Group */
-
-    interface IGroup<TValue extends OperationValue> {
-      [ABSTRACT_OPERATION_ID]: IOperation<TValue>;
-    }
-
-    /* Ring */
-
-    // prettier-ignore
-    interface IRing<TValue extends OperationValue> extends Omit<IGroup<TValue>, AbstractOperationId> {
-      add: IOperation<TValue>;
-      mul: IOperation<TValue>;
-    }
-
-    /* Field */
-
-    // prettier-ignore
-    interface IField<TValue extends OperationValue> extends Omit<IRing<TValue>, AbstractOperationId> {
-      sub: IOperation<TValue>;
-      div: IOperation<TValue>;
-    }
-  }
-}
-
-export = ASOD;
-export as namespace ASOD;
+export * from './ring';
+export * from './field';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./ring"), exports);
+_export_star(require("./field"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/ring.d.ts

@@ -0,0 +1,21 @@
+import type ASOD from './core';
+type RingOperationConfig<TValue extends ASOD.Operation.OperationValue> = {
+    func: ASOD.Operation.IBinaryOperation<TValue>;
+    neutralValue: TValue;
+};
+type RingOperationsConfig<TValue extends ASOD.Operation.OperationValue> = {
+    add: RingOperationConfig<TValue>;
+    mul: RingOperationConfig<TValue>;
+};
+type RingConfig<TValue extends ASOD.Operation.OperationValue> = {
+    operations: RingOperationsConfig<TValue>;
+};
+declare class Ring<TValue extends ASOD.Operation.OperationValue> implements ASOD.Ring.IRing<TValue> {
+    protected readonly _operations: Readonly<RingOperationsConfig<TValue>>;
+    constructor(config: RingConfig<TValue>);
+    add(a: TValue, b: TValue): TValue;
+    mul(a: TValue, b: TValue): TValue;
+    protected _compare(a: TValue, b: TValue): number;
+}
+export { Ring };
+export default Ring;

package/dist/ring.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get Ring () {
+        return Ring;
+    },
+    get default () {
+        return _default;
+    }
+});
+const _compare = require("@asod/compare");
+const _guards = require("./utils/guards");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class Ring {
+    add(a, b) {
+        const { func, neutralValue } = this._operations.add;
+        if (!this._compare(a, neutralValue)) return b;
+        if (!this._compare(b, neutralValue)) return a;
+        return func(a, b);
+    }
+    mul(a, b) {
+        const { func, neutralValue } = this._operations.mul;
+        if (!this._compare(a, neutralValue)) return b;
+        if (!this._compare(b, neutralValue)) return a;
+        return func(a, b);
+    }
+    _compare(a, b) {
+        if ((0, _guards.isComparable)(a)) return (0, _compare.compare)(a, b, a.comparator);
+        if ((0, _guards.isComparable)(b)) return (0, _compare.compare)(a, b, b.comparator);
+        return (0, _compare.compare)(a, b);
+    }
+    constructor(config){
+        _define_property(this, "_operations", void 0);
+        this._operations = config.operations;
+    }
+}
+const _default = Ring;

package/dist/utils/guards.d.ts

@@ -1,2 +1,2 @@
-import { type Field } from '../declarations/index';
-export declare const isComparable: (value: Field.OperationValue) => value is Field.IComparable;
+import type ASOD from '../core';
+export declare const isComparable: (value: ASOD.Operation.OperationValue) => value is ASOD.Operation.IComparable;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@asod/field",
   "description": "",
-  "version": "0.1.0-canary.1",
+  "version": "0.1.0-canary.2",
   "license": "MIT",
   "author": "Oleg Putseiko <oleg.putseiko@gmail.com> (https://github.com/oleg-putseiko)",
   "keywords": [],
@@ -21,7 +21,7 @@
   "scripts": {
     "build": "yarn build:js && yarn build:ts",
     "build:js": "swc src -d dist --strip-leading-paths --ignore \"node_modules,**/*.test.ts,**/*.d.ts\"",
-    "build:ts": "tsc && find src -name \"*.d.ts\" -exec cp {} dist/ \\;",
+    "build:ts": "tsc && mkdir -p dist && find src -name \"*.d.ts\" -exec cp {} dist/ \\;",
     "lint": "eslint ./src/**/*.ts -c ./eslint.config.mjs",
     "lint:fix": "yarn lint --fix && yarn format:fix",
     "lint:strict": "yarn lint --max-warnings=0 && yarn format",
@@ -32,6 +32,10 @@
     "prepare": "husky install | chmod +x ./.husky/*",
     "version:bump": "npm version -m \"build(package): bump the package version to %s\""
   },
+  "dependencies": {
+    "@asod/compare": "^0.1.1-canary.5",
+    "@asod/core": "^0.1.0-canary.1"
+  },
   "devDependencies": {
     "@commitlint/cli": "^18.2.0",
     "@commitlint/config-conventional": "^18.1.0",
@@ -54,9 +58,5 @@
   "volta": {
     "node": "20.19.5",
     "yarn": "4.10.3"
-  },
-  "dependencies": {
-    "@asod/compare": "^0.1.1-canary.1",
-    "@asod/core": "^0.1.0-canary.0"
   }
 }