argot-cli 0.0.0-stage → 0.4.0-beta

package/src/utils.ts

@@ -0,0 +1,219 @@
+import {
+  AliasTargetNotFoundError,
+  ConfigError,
+  InvalidAliasTargetError,
+  InvalidFloatError,
+  InvalidIntError,
+  InvalidOptionTypeError,
+  MissingOptionPropertyError,
+  MissingOptionTypeError,
+  UnsafeIntegerError,
+} from './errors.ts';
+import type {
+  ConfigEntry,
+  OptionType,
+  AliasEntry,
+  FloatEntry,
+  TextEntry,
+  IntEntry,
+  ListEntry,
+  ConfigEntries,
+} from './types.ts';
+
+/**
+ * Parses a string as an integer.
+ * The value must consist only of an optional sign followed by digits.
+ * The resulting number must be safely representable by the runtime.
+ * Throws:
+ * - InvalidIntError if the value is not a valid integer string
+ * - UnsafeIntegerError if the parsed value cannot be safely represented
+ */
+export function parseIntStrict(value: string): number {
+  if (!/^(-|\+)?\d+$/.test(value)) {
+    throw new InvalidIntError(value);
+  }
+
+  const num = Number(value);
+  if (!Number.isSafeInteger(num)) {
+    throw new UnsafeIntegerError(num);
+  }
+
+  return num;
+}
+
+/**
+ * Parses a string as a floating-point number.
+ * The value must consist only of:
+ * - an optional sign
+ * - digits
+ * - an optional fractional part
+ * - an optional exponent
+ *
+ * Whitespace, Infinity and NaN are not allowed.
+ *
+ * Throws:
+ * - InvalidFloatError if the value is not a valid float string
+ */
+export function parseFloatStrict(value: string): number {
+  if (!/^(-|\+)?(\d+(\.\d+)?|\.\d+)([eE](-|\+)?\d+)?$/.test(value)) {
+    throw new InvalidFloatError(value);
+  }
+
+  const num = Number(value);
+  if (!Number.isFinite(num)) {
+    throw new InvalidFloatError(value);
+  }
+
+  return num;
+}
+
+/**
+ * Validates a single configuration entry.
+ * The entry must be a labeled object containing at least the "option"
+ * and "type" properties. Additional properties are validated according
+ * to the entry type.
+ * Throws:
+ * - TypeError if the entry is not an object or contains invalid values
+ * - MissingOptionPropertyError if a required property is missing
+ * - InvalidOptionTypeError if the option type is not supported
+ */
+export function validateEntry(name: string, entry: ConfigEntry): void {
+  if (entry == null || typeof entry !== 'object') {
+    throw new TypeError('option config entry must be an object');
+  } else if (!Object.hasOwn(entry, 'type')) {
+    throw new MissingOptionTypeError(name);
+  }
+
+  const tag: OptionType = entry.type;
+
+  switch (tag) {
+    case 'flag':
+    case 'count': {
+      /* these types have no extra mandatory values */
+      break;
+    }
+    case 'text': {
+      if (!Object.hasOwn(entry, 'default'))
+        break;
+
+      const { default: def } = entry as TextEntry;
+      if (typeof def !== 'string')
+        throw new TypeError('default value must be a string');
+
+      break;
+    }
+    case 'int': {
+      if (!Object.hasOwn(entry, 'default'))
+        break;
+
+      const { default: def } = entry as IntEntry;
+      if (typeof def !== 'number' || !Number.isInteger(def))
+        throw new TypeError('default value must be an integer');
+
+      break;
+    }
+    case 'float': {
+      if (!Object.hasOwn(entry, 'default'))
+        break;
+
+      const { default: def } = entry as FloatEntry;
+      if (typeof def !== 'number' || !Number.isFinite(def))
+        throw new TypeError('default value must be a number');
+
+      break;
+    }
+    case 'list': {
+      if (!Object.hasOwn(entry, 'sep'))
+        break;
+
+      const { sep } = entry as ListEntry;
+      if (typeof sep !== 'string')
+        throw new TypeError('sep value must be a string');
+
+      break;
+    }
+    case 'alias': {
+      if (!Object.hasOwn(entry, 'target')) {
+        throw new MissingOptionPropertyError(name, 'target');
+      }
+
+      const { target } = entry as AliasEntry;
+      if (typeof target !== 'string')
+        throw new TypeError('target value must be a string');
+
+      break;
+    }
+    default: {
+      throw new InvalidOptionTypeError(tag);
+    }
+  }
+}
+
+/**
+ * Validates a set of configuration entries.
+ * Each entry is validated individually. Alias entries are validated
+ * after all entries have been processed to ensure that:
+ * - the target exists
+ * - the target is not itself an alias
+ * Throws:
+ * - Any error raised by validateEntry
+ * - AliasTargetNotFoundError if an alias target does not exist
+ * - InvalidAliasTargetError if an alias targets another alias
+ */
+export function validateEntries(entries: ConfigEntries): void {
+  const aliases: [string, string][] = [];
+
+  for (const [name, entry] of Object.entries(entries)) {
+    validateEntry(name, entry);
+    const tag: OptionType = entry.type;
+    if (tag === 'alias') {
+      const { target } = entry as AliasEntry;
+      aliases.push([name, target]);
+    }
+  }
+
+  for (const [name, target] of aliases) {
+    if (!Object.hasOwn(entries, target)) {
+      throw new AliasTargetNotFoundError(name, target);
+    }
+    const targetEntry: ConfigEntry = entries[target]!;
+    if (targetEntry.type === 'alias') {
+      throw new InvalidAliasTargetError(name, target);
+    }
+  }
+}
+
+export function validateEntriesAggregate(entries: ConfigEntries): void {
+  const aliases: [string, string][] = [];
+  const error = new ConfigError('parser configuration is not valid');
+
+  for (const [name, entry] of Object.entries(entries)) {
+    try {
+      validateEntry(name, entry);
+    } catch (err) {
+      error.push(err as Error);
+      continue;
+    }
+    const tag: OptionType = entry.type;
+    if (tag === 'alias') {
+      const { target } = entry as AliasEntry;
+      aliases.push([name, target]);
+    }
+  }
+
+  for (const [name, target] of aliases) {
+    if (!Object.hasOwn(entries, target)) {
+      error.push(new AliasTargetNotFoundError(name, target));
+      continue;
+    }
+    const targetEntry: ConfigEntry = entries[target]!;
+    if (targetEntry.type === 'alias') {
+      error.push(new InvalidAliasTargetError(name, target));
+    }
+  }
+
+  if (error.errors.length === 1)
+    throw error.errors[0];
+  else if (error.errors.length > 1)
+    throw error;
+}

package/tsconfig.json

@@ -0,0 +1,35 @@
+{
+
+  "compilerOptions": {
+    "target": "es2022",
+    "lib": ["es2022"],
+    "types": ["node"],
+    "module": "nodenext",
+    "rootDir": "./src/",
+    "moduleResolution": "nodenext",
+    "outDir": "./dist/",
+    "declaration": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "useUnknownInCatchVariables": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": false,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": false,
+    "allowUnusedLabels": false,
+    "allowUnreachableCode": false,
+    "skipLibCheck": true,
+    "rewriteRelativeImportExtensions": true
+  },
+  "include": ["src/*.ts"]
+}