@rsdk/common 5.7.0-next.2 → 6.0.0-next.0

package/src/parsers/size/size.parser.ts

@@ -0,0 +1,23 @@
+import { Size, SIZE_STRING_PATTERN } from '../../size';
+import { text } from '../../strings';
+import { Assert } from '../../types';
+import type { PropertyParser } from '../parser.interface';
+
+export class SizeParser implements PropertyParser<Size> {
+  type(): string {
+    return 'Timespan';
+  }
+
+  description(): string {
+    return text`
+      Parses string in size format into Timespan instance.
+      Format is: ${SIZE_STRING_PATTERN}. For example: 8b, 10kb, 2gb.
+    `;
+  }
+
+  parse(value: unknown): Size {
+    Assert.isString(value);
+
+    return Size.parse(value);
+  }
+}

package/src/parsers/size/size.spec.ts

@@ -0,0 +1,4 @@
+describe('SizeParser', () => {
+  /* eslint-disable @typescript-eslint/no-empty-function */
+  it('See tests in @rsdk/common', () => expect(true).toBe(true));
+});

package/src/parsers/string/index.ts

@@ -0,0 +1 @@
+export * from './string.parser';

package/src/parsers/string/string.parser.ts

@@ -0,0 +1,24 @@
+import { Assert } from '../../types';
+import type { PropertyParser } from '../parser.interface';
+
+export class StringParser implements PropertyParser<string> {
+  constructor(private readonly pattern?: RegExp) {}
+
+  type(): string {
+    return 'string';
+  }
+
+  description(): string {
+    return 'Extract arbitrary string.';
+  }
+
+  parse(value: unknown): string {
+    Assert.isString(value);
+
+    if (this.pattern) {
+      Assert.isTrue(this.pattern.test(value));
+    }
+
+    return value;
+  }
+}

package/src/parsers/string/string.spec.ts

@@ -0,0 +1,10 @@
+import { StringParser } from './string.parser';
+
+describe('StringMatcher', () => {
+  it('match', () => {
+    const parser = new StringParser(/^[a-z]+$/);
+
+    expect(parser.parse('abcd')).toBe('abcd');
+    expect(() => parser.parse('1234')).toThrow();
+  });
+});

package/src/parsers/timespan/index.ts

@@ -0,0 +1 @@
+export * from './timespan.parser';

package/src/parsers/timespan/timespan.parser.ts

@@ -0,0 +1,23 @@
+import { text } from '../../strings';
+import { Timespan, TIMESPAN_STRING_PATTERN } from '../../time';
+import { Assert } from '../../types';
+import type { PropertyParser } from '../parser.interface';
+
+export class TimespanParser implements PropertyParser<Timespan> {
+  type(): string {
+    return 'Timespan';
+  }
+
+  description(): string {
+    return text`
+      Parses string in timespan format into Timespan instance.
+      Format is: ${TIMESPAN_STRING_PATTERN}. For example: 1s, 2h, 4d.
+    `;
+  }
+
+  parse(value: unknown): Timespan {
+    Assert.isString(value);
+
+    return Timespan.parse(value);
+  }
+}

package/src/parsers/timespan/timespan.spec.ts

@@ -0,0 +1,5 @@
+describe('TimespanParser', () => {
+  /* eslint-disable @typescript-eslint/no-empty-function */
+  it('See tests for Timespan class in @rsdk/common', () =>
+    expect(true).toBe(true));
+});

package/src/parsers/url/errors.ts

@@ -0,0 +1,19 @@
+export class InvalidUrl extends Error {
+  constructor(str: string, cause: unknown) {
+    super(`Invalid url string: <${str}>`);
+    this.name = 'InvalidUrl';
+    this.cause = cause;
+  }
+}
+
+export class InvalidProtocol extends Error {
+  constructor(expectedProtocols: string[], protocol: string, url: URL) {
+    super(`Invalid protocol: <${protocol}>, expected: ${expectedProtocols}`);
+    this.name = 'InvalidProtocol';
+    this.cause = {
+      protocol,
+      url,
+      expected: expectedProtocols,
+    };
+  }
+}

package/src/parsers/url/index.ts

@@ -0,0 +1 @@
+export * from './url.parser';

package/src/parsers/url/url.parser.ts

@@ -0,0 +1,43 @@
+import { Assert } from '../../types';
+import type { PropertyParser } from '../parser.interface';
+
+import { InvalidProtocol, InvalidUrl } from './errors';
+
+export class UrlParser implements PropertyParser<URL> {
+  private readonly protocols: string[];
+
+  constructor(...protocols: string[]) {
+    this.protocols = protocols;
+  }
+
+  type(): string {
+    return 'URL';
+  }
+
+  description(): string {
+    return 'Parses string into instance of URL';
+  }
+
+  parse(value: unknown): URL {
+    Assert.isString(value);
+
+    try {
+      const url = new URL(value);
+
+      this.assertProtocol(url);
+      return url;
+    } catch (error) {
+      throw new InvalidUrl(value, error);
+    }
+  }
+
+  private assertProtocol(url: URL): void {
+    if (this.protocols.length === 0) {
+      return;
+    }
+
+    if (!this.protocols.includes(url.protocol)) {
+      throw new InvalidProtocol(this.protocols, url.protocol, url);
+    }
+  }
+}

package/src/types/assert.class.ts

@@ -15,6 +15,22 @@ export class Assert {
     throw new Error(`<${x}> is not a number.`);
   }
 
+  static isBoolean(x: unknown): asserts x is boolean {
+    if (typeof x === 'boolean') {
+      return;
+    }
+
+    throw new Error(`<${x}> is not a boolean.`);
+  }
+
+  static isTrue(x: unknown): asserts x is true {
+    if (x === true) {
+      return;
+    }
+
+    throw new Error(`<${x}> is not true.`);
+  }
+
   static isError(x: unknown): asserts x is Error {
     if (x instanceof Error) {
       return;