feat: Introduce fe modular build system

fe-app-podkop/src/main.ts

@@ -0,0 +1,4 @@
+'use strict';
+'require baseclass';
+
+export * from './validators';

fe-app-podkop/src/validators/index.ts

@@ -0,0 +1,4 @@
+export * from './validateIp';
+export * from './validateDomain';
+export * from './validateDns';
+export * from './validateUrl';

fe-app-podkop/src/validators/tests/validateDns.test.js

@@ -0,0 +1,24 @@
+import { describe, expect, it } from 'vitest';
+import { validateDNS } from '../validateDns.js';
+import { invalidIPs, validIPs } from './validateIp.test';
+import { invalidDomains, validDomains } from './validateDomain.test';
+
+const validDns = [...validIPs, ...validDomains];
+
+const invalidDns = [...invalidIPs, ...invalidDomains];
+
+describe('validateDns', () => {
+  describe.each(validDns)('Valid dns: %s', (_desc, domain) => {
+    it(`returns valid=true for "${domain}"`, () => {
+      const res = validateDNS(domain);
+      expect(res.valid).toBe(true);
+    });
+  });
+
+  describe.each(invalidDns)('Invalid dns: %s', (_desc, domain) => {
+    it(`returns valid=false for "${domain}"`, () => {
+      const res = validateDNS(domain);
+      expect(res.valid).toBe(false);
+    });
+  });
+});

fe-app-podkop/src/validators/tests/validateDomain.test.js

@@ -0,0 +1,46 @@
+import { describe, expect, it } from 'vitest';
+import { validateDomain } from '../validateDomain';
+
+export const validDomains = [
+  ['Simple domain', 'example.com'],
+  ['Subdomain', 'sub.example.com'],
+  ['With dash', 'my-site.org'],
+  ['With numbers', 'site123.net'],
+  ['Deep subdomain', 'a.b.c.example.co.uk'],
+  ['With path', 'example.com/path/to/resource'],
+  ['Punycode RU', 'xn--d1acufc.xn--p1ai'],
+  ['Adguard dns', 'dns.adguard-dns.com'],
+  ['Nextdns dns', 'dns.nextdns.io/xxxxxxx'],
+  ['Long domain (63 chars in label)', 'a'.repeat(63) + '.com'],
+];
+
+export const invalidDomains = [
+  ['No TLD', 'localhost'],
+  ['Only TLD', '.com'],
+  ['Double dot', 'example..com'],
+  ['Illegal chars', 'exa!mple.com'],
+  ['Space inside', 'exa mple.com'],
+  ['Ending with dash', 'example-.com'],
+  ['Starting with dash', '-example.com'],
+  ['Trailing dot', 'example.com.'],
+  ['Too short TLD', 'example.c'],
+  ['With protocol (not allowed)', 'http://example.com'],
+  ['Too long label (>63 chars)', 'a'.repeat(64) + '.com'],
+  ['Too long domain (>253 chars)', Array(40).fill('abcdef').join('.') + '.com'],
+];
+
+describe('validateDomain', () => {
+  describe.each(validDomains)('Valid domain: %s', (_desc, domain) => {
+    it(`returns valid=true for "${domain}"`, () => {
+      const res = validateDomain(domain);
+      expect(res.valid).toBe(true);
+    });
+  });
+
+  describe.each(invalidDomains)('Invalid domain: %s', (_desc, domain) => {
+    it(`returns valid=false for "${domain}"`, () => {
+      const res = validateDomain(domain);
+      expect(res.valid).toBe(false);
+    });
+  });
+});

fe-app-podkop/src/validators/tests/validateIp.test.js

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { validateIPV4 } from '../validateIp';
+
+export const validIPs = [
+  ['Private LAN', '192.168.1.1'],
+  ['All zeros', '0.0.0.0'],
+  ['Broadcast', '255.255.255.255'],
+  ['Simple', '1.2.3.4'],
+  ['Loopback', '127.0.0.1'],
+];
+
+export const invalidIPs = [
+  ['Octet too large', '256.0.0.1'],
+  ['Too few octets', '192.168.1'],
+  ['Too many octets', '1.2.3.4.5'],
+  ['Leading zero (1st octet)', '01.2.3.4'],
+  ['Leading zero (2nd octet)', '1.02.3.4'],
+  ['Leading zero (3rd octet)', '1.2.003.4'],
+  ['Leading zero (4th octet)', '1.2.3.004'],
+  ['Four digits in octet', '1.2.3.0004'],
+  ['Trailing dot', '1.2.3.'],
+];
+
+describe('validateIPV4', () => {
+  describe.each(validIPs)('Valid IP: %s', (_desc, ip) => {
+    it(`returns {valid:true for "${ip}"`, () => {
+      const res = validateIPV4(ip);
+      expect(res.valid).toBe(true);
+    });
+  });
+
+  describe.each(invalidIPs)('Invalid IP: %s', (_desc, ip) => {
+    it(`returns {valid:false for "${ip}"`, () => {
+      const res = validateIPV4(ip);
+      expect(res.valid).toBe(false);
+    });
+  });
+});

fe-app-podkop/src/validators/tests/validateUrl.test.js

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import { validateUrl } from '../validateUrl';
+
+const validUrls = [
+  ['Simple HTTP', 'http://example.com'],
+  ['Simple HTTPS', 'https://example.com'],
+  ['With path', 'https://example.com/path/to/page'],
+  ['With query', 'https://example.com/?q=test'],
+  ['With port', 'http://example.com:8080'],
+  ['With subdomain', 'https://sub.example.com'],
+];
+
+const invalidUrls = [
+  ['Invalid format', 'not a url'],
+  ['Missing protocol', 'example.com'],
+  ['Unsupported protocol (ftp)', 'ftp://example.com'],
+  ['Unsupported protocol (ws)', 'ws://example.com'],
+  ['Empty string', ''],
+];
+
+describe('validateUrl', () => {
+  describe.each(validUrls)('Valid URL: %s', (_desc, url) => {
+    it(`returns valid=true for "${url}"`, () => {
+      const res = validateUrl(url);
+      expect(res.valid).toBe(true);
+    });
+  });
+
+  describe.each(invalidUrls)('Invalid URL: %s', (_desc, url) => {
+    it(`returns valid=false for "${url}"`, () => {
+      const res = validateUrl(url);
+      expect(res.valid).toBe(false);
+    });
+  });
+
+  it('allows custom protocol list (ftp)', () => {
+    const res = validateUrl('ftp://example.com', ['ftp:']);
+    expect(res.valid).toBe(true);
+  });
+});

fe-app-podkop/src/validators/types.ts

@@ -0,0 +1,4 @@
+export interface ValidationResult {
+  valid: boolean;
+  message: string;
+}

fe-app-podkop/src/validators/validateDns.ts

@@ -0,0 +1,23 @@
+import { validateDomain } from './validateDomain';
+import { validateIPV4 } from './validateIp';
+import { ValidationResult } from './types.js';
+
+export function validateDNS(value: string): ValidationResult {
+  if (!value) {
+    return { valid: false, message: 'DNS server address cannot be empty' };
+  }
+
+  if (validateIPV4(value).valid) {
+    return { valid: true, message: 'Valid' };
+  }
+
+  if (validateDomain(value).valid) {
+    return { valid: true, message: 'Valid' };
+  }
+
+  return {
+    valid: false,
+    message:
+      'Invalid DNS server format. Examples: 8.8.8.8 or dns.example.com or dns.example.com/nicedns for DoH',
+  };
+}

fe-app-podkop/src/validators/validateDomain.ts

@@ -0,0 +1,21 @@
+import { ValidationResult } from './types.js';
+
+export function validateDomain(domain: string): ValidationResult {
+  const domainRegex =
+    /^(?=.{1,253}(?:\/|$))(?:(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)\.)+(?:[a-zA-Z]{2,}|xn--[a-zA-Z0-9-]{1,59}[a-zA-Z0-9])(?:\/[^\s]*)?$/;
+
+  if (!domainRegex.test(domain)) {
+    return { valid: false, message: 'Invalid domain address' };
+  }
+
+  const hostname = domain.split('/')[0];
+  const parts = hostname.split('.');
+
+  const atLeastOneInvalidPart = parts.some((part) => part.length > 63);
+
+  if (atLeastOneInvalidPart) {
+    return { valid: false, message: 'Invalid domain address' };
+  }
+
+  return { valid: true, message: 'Valid' };
+}

fe-app-podkop/src/validators/validateIp.ts

@@ -0,0 +1,12 @@
+import { ValidationResult } from './types.js';
+
+export function validateIPV4(ip: string): ValidationResult {
+  const ipRegex =
+    /^(?:(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.){3}(25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])$/;
+
+  if (ipRegex.test(ip)) {
+    return { valid: true, message: 'Valid' };
+  }
+
+  return { valid: false, message: 'Invalid IP address' };
+}

fe-app-podkop/src/validators/validateUrl.ts

@@ -0,0 +1,20 @@
+import { ValidationResult } from './types.js';
+
+export function validateUrl(
+  url: string,
+  protocols: string[] = ['http:', 'https:'],
+): ValidationResult {
+  try {
+    const parsedUrl = new URL(url);
+
+    if (!protocols.includes(parsedUrl.protocol)) {
+      return {
+        valid: false,
+        message: `URL must use one of the following protocols: ${protocols.join(', ')}`,
+      };
+    }
+    return { valid: true, message: 'Valid' };
+  } catch (e) {
+    return { valid: false, message: 'Invalid URL format' };
+  }
+}