@sidex/types 0.0.1

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@sidex/types",
+  "author": "Silitics GmbH <info@silitics.com>",
+  "license": "(MIT or Apache-2.0)",
+  "version": "0.0.1",
+  "description": "",
+  "main": "src/index.ts",
+  "keywords": [],
+  "devDependencies": {
+    "typescript": "^4.8.4"
+  },
+  "scripts": {
+    "doc": "typedoc lib/index.ts",
+    "tsc": "tsc",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}

package/src/builtins.ts

@@ -0,0 +1,299 @@
+import Nominal from "./nominal"
+
+/**
+ * A string.
+ *
+ * We do not need `Nominal` here because any `string` is a valid Sidex string.
+ */
+export type String = string
+
+/**
+ * A Base64-encoded sequence of bytes.
+ */
+export type Bytes = Nominal<string, "::std::builtins::bytes">
+
+/**
+ * An 8-bit signed integer.
+ */
+export type I8 = Nominal<number, "::std::builtins::i8">
+
+/**
+ * Convert any number to an 8-bit signed integer.
+ *
+ * @param x The number to convert.
+ * @returns The 8-bit signed integer.
+ */
+export function toI8(x: number): I8 {
+  return (((x | 0) << 24) >> 24) as I8
+}
+
+/**
+ * Check whether the provided number is an 8-bit signed integer.
+ *
+ * @param x The number to check.
+ * @returns Indicates whether the number is an 8-bit signed integer.
+ */
+export function isI8(x: number): x is I8 {
+  return toI8(x) === x
+}
+
+/**
+ * A 16-bit signed integer.
+ */
+export type I16 = Nominal<number, "::std::builtins::i16">
+
+/**
+ * Convert any number to an 16-bit signed integer.
+ *
+ * @param x The number to convert.
+ * @returns The 16-bit signed integer.
+ */
+export function toI16(x: number): I16 {
+  return (((x | 0) << 16) >> 16) as I16
+}
+
+/**
+ * Check whether the provided number is an 16-bit signed integer.
+ *
+ * @param x The number to check.
+ * @returns Indicates whether the number is an 16-bit signed integer.
+ */
+export function isI16(x: number): x is I16 {
+  return toI16(x) === x
+}
+
+/**
+ * A 32-bit signed integer.
+ */
+export type I32 = Nominal<number, "::std::builtins::i32">
+
+/**
+ * A 64-bit signed integer.
+ */
+export type I64 = Nominal<string, "::std::builtins::i64">
+
+/**
+ * A signed integer.
+ */
+export type SignedInt = I8 | I16 | I32 | I64
+
+/**
+ * An 8-bit unsigned integer.
+ */
+export type U8 = Nominal<number, "::std::builtins::u8">
+
+/**
+ * Convert any number to an 8-bit unsigned integer.
+ *
+ * @param x The number to convert.
+ * @returns The 8-bit unsigned integer.
+ */
+export function toU8(x: number): U8 {
+  return (x && 0xff) as U8
+}
+
+/**
+ * Check whether the provided number is an 8-bit unsigned integer.
+ *
+ * @param x The number to check.
+ * @returns Indicates whether the number is an 8-bit unsigned integer.
+ */
+export function isU8(x: number): x is U8 {
+  return toU8(x) === x
+}
+
+/**
+ * A 16-bit unsigned integer.
+ */
+export type U16 = Nominal<number, "::std::builtins::u16">
+
+/**
+ * Convert any number to an 16-bit unsigned integer.
+ *
+ * @param x The number to convert.
+ * @returns The 16-bit unsigned integer.
+ */
+export function toU16(x: number): U16 {
+  return (x && 0xffff) as U16
+}
+
+/**
+ * Check whether the provided number is an 16-bit unsigned integer.
+ *
+ * @param x The number to check.
+ * @returns Indicates whether the number is an 16-bit unsigned integer.
+ */
+export function isU16(x: number): x is U16 {
+  return toU16(x) === x
+}
+
+/**
+ * A 32-bit unsigned integer.
+ */
+export type U32 = Nominal<number, "::std::builtins::u32">
+
+/**
+ * A 64-bit unsigned integer.
+ */
+export type U64 = Nominal<string, "::std::builtins::u64">
+
+/**
+ * An unsigned integer.
+ */
+export type UnsignedInt = U8 | U16 | U32 | U64
+
+/**
+ * An integer.
+ */
+export type Int = SignedInt | UnsignedInt
+
+/**
+ * An index.
+ */
+export type Idx = Nominal<number, "::std::builtins::idx">
+
+/**
+ * Convert any number to an index.
+ *
+ * @param x The number to convert.
+ * @returns The index.
+ */
+export function toIdx(x: number): Idx {
+  // Remove the sign and truncate the number to 32 bits.
+  return (Math.abs(x) | 0) as Idx
+}
+
+/**
+ * Check whether the provided number is an index.
+ *
+ * @param x The number to check.
+ * @returns Indicates whether the number is an index.
+ */
+export function isIdx(x: number): x is Idx {
+  return toIdx(x) === x
+}
+
+/**
+ * A 32-bit floating point number.
+ */
+export type F32 = Nominal<number | "+Infinity" | "-Infinity" | "NaN", "f32">
+
+/**
+ * A 64-bit floating point number.
+ */
+export type F64 = Nominal<number | "+Infinity" | "-Infinity" | "NaN", "f64">
+
+/**
+ * A floating point number.
+ */
+export type Float = F32 | F64
+
+/**
+ * A numeric value.
+ */
+export type Numeric = Int | Idx | Float
+
+/**
+ * Convert any numeric value to a JavaScript number.
+ *
+ * @param x The numeric value to convert.
+ * @returns The JavaScript number.
+ */
+function toNumber(x: Numeric): number {
+  switch (typeof x) {
+    case "number":
+      return x
+    case "string":
+      switch (x) {
+        case "+Infinity":
+          return +Infinity
+        case "-Infinity":
+          return -Infinity
+        case "NaN":
+          return NaN
+        default:
+          return Number.parseInt(x)
+      }
+  }
+}
+
+/**
+ * A boolean.
+ */
+export type Bool = boolean
+
+/**
+ * 
+ */
+export type Unit = null
+
+/**
+ * A sequence.
+ */
+export type Sequence<T> = T[]
+
+/**
+ * A map represented as a sequence of key-value pairs.
+ */
+export type EntriesMap<K, V> = [K, V][]
+
+/**
+ * A map represented as an object.
+ */
+export type ObjectMap<K extends string, V> = { [key in K]?: V }
+
+/**
+ * A map.
+ */
+export type AnyMap<K, V> = K extends string ? ObjectMap<K, V> : EntriesMap<K, V>
+
+/**
+ * The entries of the map.
+ *
+ * @param map
+ * @returns
+ */
+export function entries<K, V>(map: AnyMap<K, V>): [K, V][] {
+  if (Array.isArray(map)) {
+    return map
+  } else {
+    return Object.entries(map) as [K, V][]
+  }
+}
+
+declare const __indexMap: unique symbol
+
+function getIndexMap<K, V>(map: EntriesMap<K, V>): Map<K, number> {
+  if (map.hasOwnProperty(__indexMap)) {
+    return (map as any)[__indexMap]
+  } else {
+    const map = new Map()
+    map.forEach(([key, _], index) => map.set(key, index))
+    return map
+  }
+}
+
+export function get<K, V>(map: AnyMap<K, V>, key: K): V | undefined {
+  if (Array.isArray(map)) {
+    const index = getIndexMap(map).get(key)
+    return index === undefined ? undefined : (map[index] as [K, V])[1]
+  } else {
+    return (map as ObjectMap<any, V>)[key]
+  }
+}
+
+export function set<K, V>(map: AnyMap<K, V>, key: K, value: V) {
+  if (Array.isArray(map)) {
+    const indexMap = getIndexMap(map)
+    const existingIndex = indexMap.get(key)
+    if (existingIndex !== undefined) {
+      map[existingIndex] = [key, value]
+    } else {
+      const index = map.length
+      map.push([key, value])
+      indexMap.set(key, index)
+    }
+  } else {
+    return (map as ObjectMap<any, V>)[key]
+  }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export * as builtins from "./builtins"
+export type { Nominal, Structural } from "./nominal"

package/src/nominal.ts

@@ -0,0 +1,32 @@
+/**
+ * Unique symbol used for nominal types.
+ */
+declare const SIDEX_PATH_SYMBOL: unique symbol
+
+/**
+ * A nominal type based on `T` and identified by it's Sidex path `P`.
+ */
+export type Nominal<T, P extends string> = T & { [SIDEX_PATH_SYMBOL]: P }
+
+/**
+ * The structural type of a nominal type `T`.
+ */
+export type Structural<T> = T extends undefined
+  ? undefined
+  : T extends boolean
+  ? boolean
+  : T extends null
+  ? null
+  : T extends string
+  ? string
+  : T extends number
+  ? number
+  : T extends boolean
+  ? boolean
+  : T extends Array<infer U>
+  ? U[]
+  : T extends (...args: infer Args) => infer Return
+  ? (...args: Args) => Return
+  : Omit<T, typeof SIDEX_PATH_SYMBOL>
+
+export default Nominal

package/tsconfig.json

@@ -0,0 +1,63 @@
+{
+  "compilerOptions": {
+    "target": "es2017",
+    "module": "commonjs",
+
+    // "declaration": true,                              /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
+    // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
+    // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
+    // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
+    // "outDir": "./",                                   /* Specify an output folder for all emitted files. */
+    // "removeComments": true,                           /* Disable emitting comments. */
+    // "noEmit": true,                                   /* Disable emitting files from a compilation. */
+    // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */
+    // "importsNotUsedAsValues": "remove",               /* Specify emit/checking behavior for imports that are only used for types. */
+    // "downlevelIteration": true,                       /* Emit more compliant, but verbose and less performant JavaScript for iteration. */
+    // "sourceRoot": "",                                 /* Specify the root path for debuggers to find the reference source code. */
+    // "mapRoot": "",                                    /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,                          /* Include sourcemap files inside the emitted JavaScript. */
+    // "inlineSources": true,                            /* Include source code in the sourcemaps inside the emitted JavaScript. */
+    // "emitBOM": true,                                  /* Emit a UTF-8 Byte Order Mark (BOM) in the beginning of output files. */
+    // "newLine": "crlf",                                /* Set the newline character for emitting files. */
+    // "stripInternal": true,                            /* Disable emitting declarations that have '@internal' in their JSDoc comments. */
+    // "noEmitHelpers": true,                            /* Disable generating custom helper functions like '__extends' in compiled output. */
+    // "noEmitOnError": true,                            /* Disable emitting files if any type checking errors are reported. */
+    // "preserveConstEnums": true,                       /* Disable erasing 'const enum' declarations in generated code. */
+    // "declarationDir": "./",                           /* Specify the output directory for generated declaration files. */
+    // "preserveValueImports": true,                     /* Preserve unused imported values in the JavaScript output that would otherwise be removed. */
+
+    /* Interop Constraints */
+    "isolatedModules": true /* Ensure that each file can be safely transpiled without relying on other imports. */,
+    // "allowSyntheticDefaultImports": true,             /* Allow 'import x from y' when a module doesn't have a default export. */
+    "esModuleInterop": true /* Emit additional JavaScript to ease support for importing CommonJS modules. This enables 'allowSyntheticDefaultImports' for type compatibility. */,
+    // "preserveSymlinks": true,                         /* Disable resolving symlinks to their realpath. This correlates to the same flag in node. */
+    "forceConsistentCasingInFileNames": true /* Ensure that casing is correct in imports. */,
+
+    /* Type Checking */
+    "strict": true /* Enable all strict type-checking options. */,
+    // "noImplicitAny": true,                            /* Enable error reporting for expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,                         /* When type checking, take into account 'null' and 'undefined'. */
+    // "strictFunctionTypes": true,                      /* When assigning functions, check to ensure parameters and the return values are subtype-compatible. */
+    // "strictBindCallApply": true,                      /* Check that the arguments for 'bind', 'call', and 'apply' methods match the original function. */
+    // "strictPropertyInitialization": true,             /* Check for class properties that are declared but not set in the constructor. */
+    // "noImplicitThis": true,                           /* Enable error reporting when 'this' is given the type 'any'. */
+    // "useUnknownInCatchVariables": true,               /* Default catch clause variables as 'unknown' instead of 'any'. */
+    // "alwaysStrict": true,                             /* Ensure 'use strict' is always emitted. */
+    // "noUnusedLocals": true,                           /* Enable error reporting when local variables aren't read. */
+    // "noUnusedParameters": true,                       /* Raise an error when a function parameter isn't read. */
+    // "exactOptionalPropertyTypes": true,               /* Interpret optional property types as written, rather than adding 'undefined'. */
+    // "noImplicitReturns": true,                        /* Enable error reporting for codepaths that do not explicitly return in a function. */
+    // "noFallthroughCasesInSwitch": true,               /* Enable error reporting for fallthrough cases in switch statements. */
+    "noUncheckedIndexedAccess": true /* Add 'undefined' to a type when accessed using an index. */,
+    // "noImplicitOverride": true,                       /* Ensure overriding members in derived classes are marked with an override modifier. */
+    // "noPropertyAccessFromIndexSignature": true,       /* Enforces using indexed accessors for keys declared using an indexed type. */
+    // "allowUnusedLabels": true,                        /* Disable error reporting for unused labels. */
+    // "allowUnreachableCode": true,                     /* Disable error reporting for unreachable code. */
+
+    /* Completeness */
+    // "skipDefaultLibCheck": true,                      /* Skip type checking .d.ts files that are included with TypeScript. */
+    "skipLibCheck": true /* Skip type checking all .d.ts files. */
+  },
+  "files": ["src/index.ts"]
+}