sportident.js 1.0.0 → 1.0.2

package/eslint.base.js

@@ -1,232 +0,0 @@
-const javaScriptRules = {
-    'indent': ['warn', 4, { 'SwitchCase': 1 }],
-    'semi': ['error', 'always'],
-    'no-console': [0],
-    'array-bracket-spacing': ['error', 'never'],
-    'array-bracket-newline': ['error', 'consistent'],
-    'arrow-body-style': ['error', 'as-needed'],
-    'arrow-parens': ['error', 'always'],
-    'arrow-spacing': 'error',
-    'block-scoped-var': 'error',
-    'block-spacing': 'error',
-    'brace-style': ['error', '1tbs', { 'allowSingleLine': true }],
-    'comma-dangle': ['error', { 'arrays': 'always-multiline', 'objects': 'always-multiline', 'imports': 'always-multiline', 'exports': 'always-multiline', 'functions': 'always-multiline' }],
-    'comma-spacing': ['error', { 'before': false, 'after': true }],
-    'comma-style': ['error', 'last'],
-    'computed-property-spacing': ['error', 'never'],
-    'consistent-return': 'error',
-    'curly': ['error', 'all'],
-    'default-case': 'error',
-    'dot-location': ['error', 'property'],
-    'dot-notation': 'error',
-    'eol-last': ['error', 'always'],
-    'eqeqeq': ['error', 'always'],
-    'for-direction': 'warn',
-    'func-call-spacing': ['error', 'never'],
-    'func-name-matching': 'warn',
-    'func-names': ['error', 'always'],
-    'func-style': ['error', 'declaration', { 'allowArrowFunctions': true }],
-    'function-paren-newline': ['error', 'consistent'],
-    'generator-star-spacing': ['error', { 'before': false, 'after': true }],
-    'getter-return': 'error',
-    'guard-for-in': 'warn',
-    'key-spacing': ['error', { 'beforeColon': false, 'afterColon': true }],
-    'keyword-spacing': 'error',
-    'linebreak-style': ['error', 'unix'],
-    'lines-around-directive': 'error',
-    'lines-between-class-members': ['error', 'always', { exceptAfterSingleLine: true }],
-    'no-alert': 'error',
-    'no-array-constructor': 'error',
-    'no-await-in-loop': 'error',
-    'no-buffer-constructor': 'error',
-    'no-caller': 'error',
-    'no-confusing-arrow': ['error', { 'allowParens': true }],
-    'no-continue': 'error',
-    'no-duplicate-imports': 'error',
-    'no-else-return': 'error',
-    'no-empty-function': 'off',
-    'no-eval': 'error',
-    'no-extend-native': 'error',
-    'no-floating-decimal': 'error',
-    'no-implied-eval': 'error',
-    'no-invalid-this': 'error',
-    'no-labels': 'error',
-    'no-lone-blocks': 'error',
-    'no-lonely-if': 'error',
-    'no-multi-assign': 'error',
-    'no-multi-spaces': 'error',
-    'no-multiple-empty-lines': 'error',
-    'no-native-reassign': 'error',
-    'no-negated-in-lhs': 'error',
-    'no-new-func': 'error',
-    'no-new-require': 'error',
-    'no-octal-escape': 'error',
-    'no-param-reassign': 'error',
-    'no-proto': 'error',
-    'no-return-assign': 'error',
-    'no-return-await': 'error',
-    'no-script-url': 'error',
-    'no-self-compare': 'error',
-    'no-sequences': 'error',
-    'no-shadow-restricted-names': 'error',
-    'no-spaced-func': 'error',
-    'no-tabs': 'error',
-    'no-template-curly-in-string': 'error',
-    'no-throw-literal': 'error',
-    'no-trailing-spaces': 'error',
-    'no-unneeded-ternary': 'error',
-    'no-unused-expressions': 'error',
-    'no-unused-vars': ['error', {'args': 'none'}],
-    'no-use-before-define': 'off',
-    'no-useless-concat': 'error',
-    'no-useless-constructor': 'error',
-    'no-useless-rename': 'error',
-    'no-useless-return': 'error',
-    'no-var': 'error',
-    'no-warning-comments': 'warn',
-    'no-whitespace-before-property': 'error',
-    'no-with': 'error',
-    'object-curly-newline': ['error', { 'consistent': true }],
-    'prefer-const': 'error',
-    'prefer-numeric-literals': 'error',
-    'prefer-promise-reject-errors': 'error',
-    'prefer-rest-params': 'error',
-    'prefer-template': 'error',
-    'quotes': ['error', 'single'],
-    'radix': 'error',
-    'rest-spread-spacing': 'error',
-    'semi-spacing': 'error',
-    'space-before-blocks': 'error',
-    'space-infix-ops': 'error',
-    'space-unary-ops': ['error', { 'words': true, 'nonwords': false }],
-    'spaced-comment': ['error', 'always', { 'block': { 'balanced': true } }],
-    'symbol-description': 'error',
-    'template-curly-spacing': 'error',
-    'wrap-iife': 'error',
-};
-
-const typeScriptRules = {
-    ...javaScriptRules,
-    '@typescript-eslint/ban-ts-comment': 'off',
-    '@typescript-eslint/ban-ts-ignore': 'off',
-    '@typescript-eslint/explicit-function-return-type': 'off',
-    '@typescript-eslint/explicit-module-boundary-types': 'error',
-    '@typescript-eslint/interface-name-prefix': 'off',
-    '@typescript-eslint/member-delimiter-style': 'off',
-    '@typescript-eslint/no-empty-function': 'off',
-    '@typescript-eslint/no-explicit-any': 'off',
-    '@typescript-eslint/no-non-null-assertion': 'off',
-    '@typescript-eslint/no-unused-vars': ['error', {
-        'vars': 'all',
-        'args': 'all',
-        'ignoreRestSiblings': true,
-        'argsIgnorePattern': '^_',
-        'varsIgnorePattern': '^_',
-    }],
-    '@typescript-eslint/no-shadow': ['error'],
-    '@typescript-eslint/no-use-before-define': ['error', {'classes': false, 'functions': false}],
-    '@typescript-eslint/no-useless-constructor': ['error'],
-    'no-shadow': 'off',
-    'no-unused-vars': 'off',
-    'no-useless-constructor': 'off',
-};
-
-module.exports = {
-    frontendConfig: {
-        env: {
-            browser: true,
-            es6: true,
-        },
-        extends: [
-            'eslint:recommended',
-            'plugin:react/recommended',
-        ],
-        parserOptions: {
-            ecmaVersion: 2018,
-            ecmaFeatures: {
-                jsx: true,
-            },
-            sourceType: 'module',
-        },
-        plugins: [
-            'react',
-        ],
-        settings: {
-            react: {
-                createClass: 'createReactClass',
-                pragma: 'React',
-                version: 'detect',
-                flowVersion: '0.53',
-            },
-            propWrapperFunctions: [
-                'forbidExtraProps',
-                { property: 'freeze', object: 'Object' },
-                { property: 'myFavoriteWrapper' },
-            ],
-            linkComponents: [
-                'Hyperlink',
-                { name: 'Link', linkAttribute: 'to' },
-            ],
-        },
-        rules: javaScriptRules,
-        overrides: [
-            {
-                files: ['**/*.ts', '**/*.tsx'],
-                env: {
-                    browser: true,
-                    es6: true,
-                },
-                extends: [
-                    'eslint:recommended',
-                    'plugin:react/recommended',
-                    'plugin:@typescript-eslint/eslint-recommended',
-                    'plugin:@typescript-eslint/recommended',
-                ],
-                globals: { 'Atomics': 'readonly', 'SharedArrayBuffer': 'readonly' },
-                parser: '@typescript-eslint/parser',
-                parserOptions: {
-                    'ecmaVersion': 2018,
-                    'sourceType': 'module',
-                },
-                plugins: ['@typescript-eslint'],
-                rules: typeScriptRules,
-            },
-        ],
-    },
-    nodeConfig: {
-        env: {
-            node: true,
-            es6: true,
-        },
-        extends: [
-            'eslint:recommended',
-        ],
-        parserOptions: {
-            ecmaVersion: 2018,
-            sourceType: 'module',
-        },
-        rules: javaScriptRules,
-        overrides: [
-            {
-                files: ['**/*.ts', '**/*.tsx'],
-                env: {
-                    browser: true,
-                    es6: true,
-                },
-                extends: [
-                    'eslint:recommended',
-                    'plugin:@typescript-eslint/eslint-recommended',
-                    'plugin:@typescript-eslint/recommended',
-                ],
-                globals: { 'Atomics': 'readonly', 'SharedArrayBuffer': 'readonly' },
-                parser: '@typescript-eslint/parser',
-                parserOptions: {
-                    'ecmaVersion': 2018,
-                    'sourceType': 'module',
-                },
-                plugins: ['@typescript-eslint'],
-                rules: typeScriptRules,
-            },
-        ],
-    },
-};

package/install.sh

@@ -1,6 +0,0 @@
-#!/bin/sh
-
-cat <<EOM >/etc/udev/rules.d/99-sportident.rules
-SUBSYSTEM=="usb", ATTRS{idVendor}=="10c4", ATTRS{idProduct}=="800a", MODE="0660", GROUP="plugdev", RUN="/bin/sh -c 'echo -n \$id:1.0 > /sys/bus/usb/drivers/cp210x/unbind'"
-EOM
-udevadm control --reload

package/jest.config.ts

@@ -1,49 +0,0 @@
-import type {Config} from 'jest';
-
-const totalCoverage = {
-    branches: 100,
-    functions: 100,
-    lines: 100,
-    statements: 100,
-};
-
-const percentCoverage = (percent: number) => ({
-    branches: percent,
-    functions: percent,
-    lines: percent,
-    statements: percent,
-})
-
-const jestConfig: Config = {
-    transform: {
-        '^.+\\.tsx?$': 'ts-jest',
-    },
-    testEnvironment: 'jsdom',
-    testRegex: '.*/.*\\.test\\.tsx?',
-    testPathIgnorePatterns: ['node_modules/', 'lib/', '__snapshots__/', 'testUtils/'],
-    collectCoverage: true,
-    collectCoverageFrom: [
-        './**/src/**/*',
-    ],
-    coveragePathIgnorePatterns: ['node_modules/', 'lib/', '__snapshots__/', 'testUtils/'],
-    maxConcurrency: 1,
-    coverageThreshold: {
-        global: percentCoverage(10),
-        './src/': {
-            branches: 92,
-            functions: 89,
-            lines: 89,
-            statements: 88,
-        },
-        './src/SiCard': percentCoverage(92),
-        './src/SiDevice': percentCoverage(44),
-        './src/fakes': percentCoverage(43),
-        './src/SiStation': percentCoverage(83),
-        './src/storage': totalCoverage,
-        './src/utils': totalCoverage,
-        './src/constants.ts': totalCoverage,
-        './src/siProtocol.ts': totalCoverage,
-        './src/testUtils.ts': totalCoverage,
-    },
-};
-export default jestConfig;

package/nx.json

@@ -1,39 +0,0 @@
-{
-  "tasksRunnerOptions": {
-    "default": {
-      "runner": "nx/tasks-runners/default",
-      "options": {
-        "cacheableOperations": [
-          "build",
-          "eslint",
-          "tsc",
-          "webpack",
-          "typedoc"
-        ]
-      }
-    }
-  },
-  "namedInputs": {
-    "src": ["{projectRoot}/src/**/*"],
-    "babelconfig": ["{workspaceRoot}/babel.config.js"],
-    "eslintconfig": ["{workspaceRoot}/eslint.base.js", "{workspaceRoot}/.eslintignore"],
-    "tsconfig": ["{workspaceRoot}/tsconfig.base.json", "{workspaceRoot}/tsconfig.json"]
-  },
-  "targetDefaults": {
-    "build": {
-      "outputs": ["{projectRoot}/lib"]
-    },
-    "eslint": {
-      "inputs": ["src", "eslintconfig", "tsconfig"]
-    },
-    "tsc": {
-      "outputs": ["{projectRoot}/lib"]
-    },
-    "webpack": {
-      "outputs": ["{projectRoot}/build"]
-    },
-    "typedoc": {
-      "outputs": ["{projectRoot}/docs"]
-    }
-  }
-}

package/src/SiCard/BaseSiCard.test.ts

@@ -1,187 +0,0 @@
-import { beforeEach, describe, expect, test } from '@jest/globals';
-import { proto } from '../constants';
-import type * as siProtocol from '../siProtocol';
-import { BaseSiCard } from './BaseSiCard';
-
-beforeEach(() => {
-	BaseSiCard.resetNumberRangeRegistry();
-});
-
-describe('BaseSiCard', () => {
-	class FakeSiCard1 extends BaseSiCard {
-		static typeSpecificInstanceFromMessage(_message: siProtocol.SiMessage): FakeSiCard1 | undefined {
-			return undefined;
-		}
-
-		typeSpecificRead() {
-			return Promise.resolve();
-		}
-	}
-	class FakeSiCard2 extends BaseSiCard {
-		static typeSpecificInstanceFromMessage(_message: siProtocol.SiMessage): FakeSiCard2 | undefined {
-			return undefined;
-		}
-
-		typeSpecificRead() {
-			return Promise.resolve();
-		}
-	}
-
-	test('registerNumberRange', () => {
-		BaseSiCard.registerNumberRange(100, 1000, FakeSiCard1);
-		BaseSiCard.registerNumberRange(0, 100, FakeSiCard2);
-		BaseSiCard.registerNumberRange(1000, 2000, FakeSiCard2);
-		expect(BaseSiCard.getTypeByCardNumber(-1)).toEqual(undefined);
-		expect(BaseSiCard.getTypeByCardNumber(0)).toEqual(FakeSiCard2);
-		expect(BaseSiCard.getTypeByCardNumber(99)).toEqual(FakeSiCard2);
-		expect(BaseSiCard.getTypeByCardNumber(100)).toEqual(FakeSiCard1);
-		expect(BaseSiCard.getTypeByCardNumber(999)).toEqual(FakeSiCard1);
-		expect(BaseSiCard.getTypeByCardNumber(1000)).toEqual(FakeSiCard2);
-		expect(BaseSiCard.getTypeByCardNumber(1999)).toEqual(FakeSiCard2);
-		expect(BaseSiCard.getTypeByCardNumber(2000)).toEqual(undefined);
-	});
-	test('fromCardNumber', () => {
-		BaseSiCard.registerNumberRange(100, 1000, FakeSiCard1);
-		const siCard500 = BaseSiCard.fromCardNumber(500);
-		expect(siCard500 instanceof BaseSiCard).toBe(true);
-		expect(siCard500 instanceof FakeSiCard1).toBe(true);
-		const siCard5000 = BaseSiCard.fromCardNumber(5000);
-		expect(siCard5000).toBe(undefined);
-	});
-	describe('detectFromMessage', () => {
-		let triedToGetInstance = false;
-		class SiCard1 extends BaseSiCard {
-			static typeSpecificInstanceFromMessage(message: siProtocol.SiMessage) {
-				triedToGetInstance = true;
-				if (message.mode !== undefined) {
-					return undefined;
-				}
-				return new SiCard1(1);
-			}
-
-			typeSpecificRead() {
-				return Promise.resolve();
-			}
-		}
-
-		beforeEach(() => {
-			BaseSiCard.registerNumberRange(1000, 10000, SiCard1);
-			BaseSiCard.registerNumberRange(10000, 20000, FakeSiCard2);
-		});
-
-		test('detects card from valid message', () => {
-			expect(triedToGetInstance).toBe(false);
-			const siCard500 = BaseSiCard.detectFromMessage({
-				command: proto.cmd.SI5_DET,
-				parameters: []
-			});
-			expect(triedToGetInstance).toBe(true);
-			expect(siCard500 instanceof SiCard1).toBe(true);
-			expect(siCard500?.cardNumber).toBe(1);
-		});
-
-		test('does not detect from NAK message', () => {
-			const nakMessage = BaseSiCard.detectFromMessage({
-				mode: proto.NAK
-			});
-			expect(nakMessage).toBe(undefined);
-		});
-	});
-	test('read', async () => {
-		class SiCard1 extends BaseSiCard {
-			typeSpecificRead() {
-				this.raceResult.startTime = {time:1};
-				return Promise.resolve();
-			}
-		}
-		const siCard500 = new SiCard1(500);
-		try {
-			await siCard500.confirm();
-			expect({ canConfirm: true }).toEqual({ canConfirm: false });
-		} catch (err) {
-			// ignore
-		}
-		siCard500.mainStation = {
-			sendMessage: (_message: siProtocol.SiMessage, _numResponses?: number) => Promise.resolve([])
-		};
-		const result = await siCard500.read();
-		expect(result).toBe(siCard500);
-		expect(JSON.stringify(siCard500.raceResult.startTime)).toBe(JSON.stringify({time:1}));
-		await siCard500.confirm();
-	});
-	const emptySiCard = new FakeSiCard1(501);
-	const nonemptySiCard = new FakeSiCard1(502);
-	nonemptySiCard.raceResult = {
-		cardNumber: 502,
-		clearTime: {time:1},
-		checkTime: {time:2},
-		startTime: {time:1},
-		punches: [{ code: 31, time: {time:2} }],
-		finishTime: {time:1},
-		cardHolder: { firstName: 'John' }
-	};
-	test('Empty SiCard toDict', async () => {
-		expect(emptySiCard.toDict()).toEqual({
-			cardNumber: 501,
-			clearTime: undefined,
-			checkTime: undefined,
-			startTime: undefined,
-			finishTime: undefined,
-			punches: undefined,
-			cardHolder: undefined
-		});
-	});
-	test('Non-empty SiCard toDict', async () => {
-		expect(nonemptySiCard.toDict()).toEqual({
-			cardNumber: 502,
-			clearTime: {time:1},
-			checkTime: {time:2},
-			startTime: {time:1},
-			finishTime: {time:1},
-			punches: [{ code: 31, time: {time:2} }],
-			cardHolder: { firstName: 'John' }
-		});
-	});
-	test('Empty SiCard toString', async () => {
-		expect(emptySiCard.toString()).toEqual('FakeSiCard1\nCard Number: 501\nClear: ?\nCheck: ?\nStart: ?\nFinish: ?\n? Punches\nCard Holder:\n?\n');
-	});
-	test('Non-empty SiCard toString', async () => {
-		expect(nonemptySiCard.toString()).toEqual('FakeSiCard1\nCard Number: 502\nClear: 1\nCheck: 2\nStart: 1\nFinish: 1\n31: 2\nCard Holder:\nfirstName: John\n');
-	});
-	test('Empty SiCard getMonotonizedRaceResult', async () => {
-		expect(emptySiCard.getMonotonizedRaceResult()).toEqual({
-			cardNumber: 501,
-			clearTime: undefined,
-			checkTime: undefined,
-			startTime: undefined,
-			finishTime: undefined,
-			punches: undefined,
-			cardHolder: undefined
-		});
-	});
-	test('Non-empty SiCard getMonotonizedRaceResult', async () => {
-		expect(nonemptySiCard.getMonotonizedRaceResult()).toEqual({
-			cardNumber: 502,
-			clearTime: {time:1},
-			checkTime: {time:2},
-			startTime: {time:43201},
-			finishTime: {time:86401},
-			punches: [{ code: 31, time: {time:43202} }],
-			cardHolder: { firstName: 'John' }
-		});
-	});
-	test('Empty SiCard getNormalizedRaceResult', async () => {
-		expect(() => emptySiCard.getNormalizedRaceResult()).toThrow();
-	});
-	test('Non-empty SiCard getNormalizedRaceResult', async () => {
-		expect(nonemptySiCard.getNormalizedRaceResult()).toEqual({
-			cardNumber: 502,
-			clearTime: {time:-43200},
-			checkTime: {time:-43199},
-			startTime: {time:0},
-			finishTime: {time:43200},
-			punches: [{ code: 31, time: {time:1} }],
-			cardHolder: { firstName: 'John' }
-		});
-	});
-});

package/src/SiCard/BaseSiCard.ts

@@ -1,101 +0,0 @@
-import _ from 'lodash';
-import { proto } from '../constants';
-import * as utils from '../utils';
-import type * as siProtocol from '../siProtocol';
-import type * as storage from '../storage';
-import type { IRaceResultData } from './IRaceResultData';
-import { makeStartZeroTime, monotonizeRaceResult, prettyRaceResult } from './raceResultTools';
-
-export type SiCardType<T extends BaseSiCard> = {
-	new (cardNumber: number): T;
-	typeSpecificInstanceFromMessage: (message: siProtocol.SiMessage) => T | undefined;
-};
-const initialRegistry: utils.NumberRangeRegistry<SiCardType<BaseSiCard>> = new utils.NumberRangeRegistry();
-
-export interface ISiMainStation {
-	sendMessage: (message: siProtocol.SiMessage, numResponses?: number, timeoutInMiliseconds?: number) => Promise<number[][]>;
-}
-
-export abstract class BaseSiCard {
-	// abstract static maxNumPunches: number;
-	static NumberRange: typeof utils.NumberRange = utils.NumberRange;
-	static cardNumberRangeRegistry: utils.NumberRangeRegistry<SiCardType<BaseSiCard>> = initialRegistry;
-
-	static resetNumberRangeRegistry(): void {
-		this.cardNumberRangeRegistry = new utils.NumberRangeRegistry();
-	}
-
-	static registerNumberRange<T extends BaseSiCard>(firstCardNumberInRange: number, firstCardNumberAfterRange: number, siCardType: SiCardType<T>): void {
-		const cardNumberRange = new utils.NumberRange(firstCardNumberInRange, firstCardNumberAfterRange);
-		this.cardNumberRangeRegistry.register(cardNumberRange, siCardType);
-	}
-
-	static getTypeByCardNumber<T extends BaseSiCard>(cardNumber: number): SiCardType<T> | undefined {
-		return this.cardNumberRangeRegistry.getValueForNumber(cardNumber) as SiCardType<T> | undefined;
-	}
-
-	// abstract static getPunchOffset(index: number): number;
-
-	static fromCardNumber(cardNumber: number): BaseSiCard | undefined {
-		const cardType = this.getTypeByCardNumber(cardNumber);
-		if (!cardType) {
-			return undefined;
-		}
-		return new cardType(cardNumber);
-	}
-
-	static detectFromMessage(message: siProtocol.SiMessage): BaseSiCard | undefined {
-		const possibleCards = this.cardNumberRangeRegistry.values.map((cardType) => cardType.typeSpecificInstanceFromMessage(message)).filter((cardInstance) => cardInstance !== undefined);
-		return possibleCards.get(0);
-	}
-
-	// abstract static typeSpecificInstanceFromMessage<Fields extends IBaseSiCardStorageFields>(
-	//     _message: siProtocol.SiMessage,
-	// ): BaseSiCard<Fields>|undefined;
-
-	public mainStation?: ISiMainStation | undefined;
-	public raceResult: IRaceResultData & { cardNumber: number };
-	public storage: storage.ISiStorage<unknown> = {} as storage.ISiStorage<unknown>;
-
-	constructor(cardNumber: number) {
-		this.raceResult = { cardNumber: cardNumber };
-	}
-
-	get cardNumber(): number {
-		return this.raceResult.cardNumber;
-	}
-
-	read(): Promise<BaseSiCard> {
-		return this.typeSpecificRead().then(() => this);
-	}
-
-	getNormalizedRaceResult(): IRaceResultData {
-		return makeStartZeroTime(this.getMonotonizedRaceResult());
-	}
-
-	getMonotonizedRaceResult(): IRaceResultData {
-		return monotonizeRaceResult(this.raceResult);
-	}
-
-	abstract typeSpecificRead(): Promise<void>;
-
-	confirm(): Promise<number[][]> {
-		if (!this.mainStation) {
-			return Promise.reject(new Error('No main station'));
-		}
-		return this.mainStation.sendMessage(
-			{
-				mode: proto.ACK
-			},
-			0
-		);
-	}
-
-	toDict(): IRaceResultData {
-		return this.raceResult;
-	}
-
-	toString(): string {
-		return `${this.constructor.name}\n${prettyRaceResult(this.raceResult)}`;
-	}
-}

package/src/SiCard/IRaceResultData.ts

@@ -1,16 +0,0 @@
-import type * as siProtocol from '../siProtocol';
-
-export interface IRaceResultData {
-	cardNumber?: number;
-	cardHolder?: { [property: string]: unknown };
-	clearTime?: siProtocol.SiTimestamp;
-	checkTime?: siProtocol.SiTimestamp;
-	startTime?: siProtocol.SiTimestamp;
-	finishTime?: siProtocol.SiTimestamp;
-	punches?: IPunch[];
-}
-
-export interface IPunch {
-	code: number;
-	time: siProtocol.SiTimestamp;
-}

package/src/SiCard/ISiCard.ts

@@ -1,23 +0,0 @@
-import type * as storage from '../storage';
-import type * as siProtocol from '../siProtocol';
-import type { IPunch, IRaceResultData } from './IRaceResultData';
-
-export interface ISiCard {
-	cardNumber: number;
-	storage: storage.ISiStorage<IBaseSiCardStorageFields>;
-	read: () => Promise<ISiCard>;
-	confirm: () => Promise<unknown>;
-	toDict: () => IRaceResultData;
-	toString: () => string;
-}
-
-export interface IBaseSiCardStorageFields {
-	cardNumber: number;
-	clearTime?: siProtocol.SiTimestamp;
-	checkTime: siProtocol.SiTimestamp;
-	startTime: siProtocol.SiTimestamp;
-	finishTime: siProtocol.SiTimestamp;
-	punchCount: number;
-	punches: IPunch[];
-	cardHolder: { [key: string]: unknown };
-}

package/src/SiCard/ISiCardExamples.ts

@@ -1,4 +0,0 @@
-export interface SiCardSample {
-	cardData: { [attr: string]: unknown } & { cardNumber: number };
-	storageData: (number | undefined)[];
-}