fix(typing)!: remove record, rename callback to Callback and TypeOf to TypeOfEnum (#110)

lowlighter · web-flow · commit ccb8de3cd680 · 2025-10-02T18:02:53.000-04:00
diff --git a/.github/deno_bump.ts b/.github/deno_bump.ts
@@ -1,6 +1,5 @@
-// deno-lint-ignore-file no-console no-external-import
+// deno-lint-ignore-file no-console no-external-import no-import-prefix
 // Imports
-import type { record } from "@libs/typing"
 import { fromFileUrl, resolve } from "@std/path"
 import { parseArgs } from "@std/cli"
 import { assert } from "jsr:@std/assert@^1.0.14"
@@ -18,7 +17,7 @@ console.log(`patching: ${path}`)
 
 // Patch config version
 const raw = await Deno.readTextFile(path)
-const config = JSONC.parse(raw) as record<string>
+const config = JSONC.parse(raw) as Record<PropertyKey, string>
 const { version: previous } = config
 console.log(`version: ${previous} → ${version}`)
 assert(semver.greaterThan(semver.parse(version), semver.parse(previous)), "expected new version to be greater than previous one")
diff --git a/.github/deno_flags.ts b/.github/deno_flags.ts
@@ -1,6 +1,5 @@
 // deno-lint-ignore-file no-console
 // Imports
-import type { record } from "@libs/typing"
 import { parseArgs } from "@std/cli"
 import { flags } from "@libs/testing/permissions"
 import * as JSONC from "@std/jsonc"
@@ -12,6 +11,6 @@ if (cwd) {
 }
 
 // Resolve config path and parse JSONC
-const config = JSONC.parse(await Deno.readTextFile("./deno.jsonc")) as record
+const config = JSONC.parse(await Deno.readTextFile("./deno.jsonc")) as Record<PropertyKey, unknown>
 
 console.log(flags(config["test:permissions"] ?? null))
diff --git a/.github/deno_readme.ts b/.github/deno_readme.ts
@@ -1,4 +1,4 @@
-// deno-lint-ignore-file no-external-import
+// deno-lint-ignore-file no-external-import no-import-prefix
 // Imports
 import { expandGlob } from "jsr:@std/fs@^1.0.19"
 import { basename, dirname, fromFileUrl, resolve } from "@std/path"
diff --git a/bundle/ts/publish/mod.ts b/bundle/ts/publish/mod.ts
@@ -3,6 +3,6 @@
  * @module
  */
 export type { DeepReadonly, Logger } from "@libs/logger"
-export type { Arg, record } from "@libs/typing"
+export type { Arg } from "@libs/typing"
 export { type package_output, type packaged, publish as publishNpm, type registry } from "./npm.ts"
 export { type options as publish_x_options, publish as publishX } from "./x.ts"
diff --git a/bundle/ts/publish/npm.ts b/bundle/ts/publish/npm.ts
@@ -5,19 +5,19 @@
 
 // Imports
 import * as JSONC from "@std/jsonc"
-import type { Arg, Optional, record } from "@libs/typing"
+import type { Arg, Optional } from "@libs/typing"
 import { assertMatch } from "@std/assert"
 import { Logger } from "@libs/logger"
 import { bundle } from "../bundle.ts"
 import { dirname, resolve, toFileUrl } from "@std/path"
 import { command } from "@libs/run/command"
-export type { Arg, Logger, record }
+export type { Arg, Logger }
 
 /** Transform a `deno.jsonc` file into a `package.json` and bundle exported entrypoints to make package publishable on json. */
 export async function packaged(path = "deno.jsonc", { logger: log = new Logger(), scope = undefined as Optional<string>, name = undefined as Optional<string> } = {}): Promise<package_output> {
   path = resolve(path)
   log.debug(`processing: ${path}`)
-  const mod = JSONC.parse(await Deno.readTextFile(path)) as record<string> & { exports?: record<string> }
+  const mod = JSONC.parse(await Deno.readTextFile(path)) as Record<PropertyKey, string> & { exports?: Record<PropertyKey, string> }
   // Validate package name
   assertMatch(mod.name, /^@[a-z0-9-]+\/[a-z0-9-]+$/)
   const [_scope, _name] = mod.name.split("/")
@@ -47,7 +47,7 @@ export async function packaged(path = "deno.jsonc", { logger: log = new Logger()
   }
 
   // Copy exports
-  const exports = {} as record<string>
+  const exports = {} as Record<PropertyKey, string>
   if (mod.exports) {
     json.exports = {}
     for (const [key, value] of Object.entries(mod.exports) as [string, string][]) {
@@ -114,20 +114,20 @@ export type package_output = {
     name: string
     version: string
     type: "module"
-    scripts: record<string>
-    exports?: record<string>
+    scripts: Record<PropertyKey, string>
+    exports?: Record<PropertyKey, string>
     description?: string
     keywords?: string | string[]
     license?: string
     author?: string
     homepage?: string
     repository?: string
     funding?: string
-    dependencies: record<string>
-    devDependencies?: record<string>
+    dependencies: Record<PropertyKey, string>
+    devDependencies?: Record<PropertyKey, string>
   }
   /** Exported entrypoints. */
-  exports: record<string>
+  exports: Record<PropertyKey, string>
 }
 
 /** Registry configuration. */
diff --git a/bundle/ts/publish/x.ts b/bundle/ts/publish/x.ts
@@ -12,7 +12,6 @@ import { retry } from "@std/async/retry"
 import * as JSONC from "@std/jsonc"
 import { expandGlob } from "@std/fs"
 import { resolve } from "@std/path"
-import type { record } from "@libs/typing"
 import { unmap as _unmap } from "../unmap.ts"
 export type { Logger }
 
@@ -234,7 +233,7 @@ export async function publish({ logger: log = new Logger(), token, repository, d
 /** Resolve import map. */
 async function unmap({ log: logger, map, exclude = [], dryrun }: { log: Logger; map: string; directory?: string; exclude?: string[]; dryrun?: boolean }) {
   const root = resolve(".").replaceAll("\\", "/")
-  const { imports } = JSONC.parse(await Deno.readTextFile(resolve(root, map))) as record<record<string>>
+  const { imports } = JSONC.parse(await Deno.readTextFile(resolve(root, map))) as Record<PropertyKey, Record<PropertyKey, string>>
   exclude.push("node_modules")
   logger.log(`processing files in ${root}`)
   for await (const { path } of expandGlob("**/*.ts", { root, exclude })) {
diff --git a/bundle/ts/testing/test_specifiers.ts b/bundle/ts/testing/test_specifiers.ts
@@ -1,6 +1,6 @@
-// deno-lint-ignore-file no-console no-external-import
+// deno-lint-ignore-file no-console no-external-import no-import-prefix
 // Example module with specifiers
-import { red } from "jsr:@std/fmt/colors"
+import { red } from "jsr:@std/fmt@1/colors"
 import { inspect } from "node:util"
 console.log(red, inspect)
 console.log("success" as string)
diff --git a/bundle/ts/unmap.ts b/bundle/ts/unmap.ts
@@ -1,13 +1,12 @@
 // Imports
 import { Logger } from "@libs/logger"
-import type { Nullable, record } from "@libs/typing"
-export type { record }
+import type { Nullable } from "@libs/typing"
 
 /** Regex for `imports` parsing. */
 const regex = /^(?<statement>import\s*(?:(?:\s+type)?\s+(?:[^\n]+?|(?:\{[\s\S]*?\}))\s+from\s+)?(?<quote>["']))(?<module>[^\n]+?)\k<quote>/gm
 
 /** Resolves all imports from file content against an import map. */
-export function unmap(content: string, imports: record<string>, { logger: log = new Logger() } = {}): { result: string; resolved: number } {
+export function unmap(content: string, imports: Record<PropertyKey, string>, { logger: log = new Logger() } = {}): { result: string; resolved: number } {
   let resolved = 0
   const directories = Object.keys(imports).filter((module) => module.endsWith("/")) as string[]
   const result = content.replace(regex, function (match, statement, quote, module, i) {
diff --git a/bundle/wasm/bundle.ts b/bundle/wasm/bundle.ts
@@ -6,9 +6,7 @@ import { UntarStream } from "@std/tar/untar-stream"
 import { ensureFile } from "@std/fs"
 import { basename, dirname, resolve, toFileUrl } from "@std/path"
 import { Logger } from "@libs/logger"
-import type { record } from "@libs/typing"
 import { command } from "@libs/run/command"
-export type { record }
 
 /**
  * Build WASM, bundle and minify JavaScript.
@@ -22,7 +20,7 @@ export type { record }
  *
  * @module
  */
-export async function bundle(project: string, { bin = "wasm-pack", autoinstall = false, banner, logger: log = new Logger(), env = {} } = {} as { bin?: string; autoinstall?: boolean; banner?: string; logger?: Logger; env?: record<string> }): Promise<void> {
+export async function bundle(project: string, { bin = "wasm-pack", autoinstall = false, banner, logger: log = new Logger(), env = {} } = {} as { bin?: string; autoinstall?: boolean; banner?: string; logger?: Logger; env?: Record<PropertyKey, string> }): Promise<void> {
   log = log.with({ project })
 
   // Check that cargo is installed
diff --git a/deno.jsonc b/deno.jsonc
@@ -54,9 +54,9 @@
   ],
   "nodeModulesDir": "auto",
   "imports": {
-    "@std/cli": "jsr:@std/cli@^1.0.21",
-    "@std/fmt": "jsr:@std/fmt@1",
-    "@std/jsonc": "jsr:@std/jsonc@1",
+    "@std/cli": "jsr:@std/cli@^1.0.22",
+    "@std/fmt": "jsr:@std/fmt@^1.0.8",
+    "@std/jsonc": "jsr:@std/jsonc@^1.0.2",
     "@std/path": "jsr:@std/path@^1.1.2"
   },
   "test:permissions": true,
diff --git a/deno.lock b/deno.lock
diff --git a/dom/_.ts b/dom/_.ts
@@ -1,7 +1,7 @@
 // deno-lint-ignore triple-slash-reference
 /// <reference lib="dom" />
 // Imports
-import type { record, rw } from "@libs/typing"
+import type { rw } from "@libs/typing"
 
 /** Implementation version */
 export const version = "0.0"
@@ -65,7 +65,7 @@ new Set(Object.getOwnPropertyNames(Array)).difference(
     "name",
     "length",
   ]),
-).forEach((property) => (Indexable as unknown as record)[property] = undefined)
+).forEach((property) => (Indexable as unknown as Record<PropertyKey, unknown>)[property] = undefined)
 new Set(Object.getOwnPropertyNames(Array.prototype)).difference(
   new Set([
     "constructor",
@@ -77,7 +77,7 @@ new Set(Object.getOwnPropertyNames(Array.prototype)).difference(
     "length",
     "toString",
   ]),
-).forEach((property) => (Indexable.prototype as unknown as record)[property] = undefined)
+).forEach((property) => (Indexable.prototype as unknown as Record<PropertyKey, unknown>)[property] = undefined)
 
 // DOM re-exports
 
diff --git a/orm/api/graphql.ts b/orm/api/graphql.ts
@@ -1,7 +1,7 @@
 // Imports
 import { toCamelCase } from "@std/text/to-camel-case"
 import { toPascalCase as titleCase } from "@std/text/to-pascal-case"
-import type { Arg, Arrayable, record, rw } from "@libs/typing"
+import type { Arg, Arrayable, rw } from "@libs/typing"
 import type { Resource } from "../resource.ts"
 import { makeExecutableSchema } from "@graphql-tools/schema"
 import { printWithComments } from "@graphql-tools/utils"
@@ -48,18 +48,18 @@ export function toGraphQLDefinition(name: string | Arrayable<typeof Resource>, s
  */
 export function graphql(
   resources: Arrayable<typeof Resource>,
-  { graphiql = true, ...options } = {} as { graphiql?: boolean; typedefs?: string; resolvers?: record },
+  { graphiql = true, ...options } = {} as { graphiql?: boolean; typedefs?: string; resolvers?: Record<PropertyKey, unknown> },
 ): { schema: ReturnType<typeof makeExecutableSchema>; handler: ReturnType<typeof GraphQLHTTP> } {
   const schema = makeExecutableSchema(toGraphQLSchema([resources].flat(), { raw: true, ...options }))
   return { schema, handler: GraphQLHTTP({ schema, graphiql }) }
 }
 
 /** Convert a {@link Resource} to a GraphQL schema. */
-function toGraphQLSchema(resources: Array<typeof Resource>, options?: { raw?: false; typedefs?: string; resolvers?: record }): string
+function toGraphQLSchema(resources: Array<typeof Resource>, options?: { raw?: false; typedefs?: string; resolvers?: Record<PropertyKey, unknown> }): string
 /** Convert a {@link Resource} to a GraphQL schema components. */
-function toGraphQLSchema(resources: Array<typeof Resource>, options: { raw: true; typedefs?: string; resolvers?: record }): { typeDefs: ast; resolvers: resolvers }
+function toGraphQLSchema(resources: Array<typeof Resource>, options: { raw: true; typedefs?: string; resolvers?: Record<PropertyKey, unknown> }): { typeDefs: ast; resolvers: resolvers }
 /** Convert a {@link Resource} to a GraphQL schema or schema components. */
-function toGraphQLSchema(resources: Array<typeof Resource>, { raw = false, typedefs: _typedefs = "", resolvers: _resolvers = {} } = {} as { raw?: boolean; typedefs?: string; resolvers?: record }): string | { typeDefs: ast; resolvers: resolvers } {
+function toGraphQLSchema(resources: Array<typeof Resource>, { raw = false, typedefs: _typedefs = "", resolvers: _resolvers = {} } = {} as { raw?: boolean; typedefs?: string; resolvers?: Record<PropertyKey, unknown> }): string | { typeDefs: ast; resolvers: resolvers } {
   const definitions = new Map<string, string>()
   const resolvers = new Map<string, resolvers>()
   for (const resource of resources) {
diff --git a/orm/resource.ts b/orm/resource.ts
@@ -2,7 +2,7 @@
 import type { key, Store, version } from "./store/store.ts"
 import type { Logger } from "@libs/logger"
 import { ulid } from "@std/ulid"
-import type { Arg, Arrayable, callback, DeepPartial, Nullable, record, rw } from "@libs/typing"
+import type { Arg, Arrayable, Callback, DeepPartial, Nullable, rw } from "@libs/typing"
 import { is, schema } from "./is/mod.ts"
 export type { _model, DeepPartial, Logger, Nullable, ulid }
 
@@ -144,15 +144,15 @@ export class Resource<T extends model> {
   }
 
   /** Readonly fields (these are computed looking at `@readonly` presence in model descriptions). */
-  protected static readonly readonly = {} as record<true>
+  protected static readonly readonly = {} as Record<PropertyKey, true>
 
   /** Readonly fields (these are computed looking at `@readonly` presence in model descriptions). */
-  protected get readonly(): record<true> {
+  protected get readonly(): Record<PropertyKey, true> {
     return (this.constructor as typeof Resource).readonly
   }
 
   /** Listeners. */
-  protected static readonly listeners = {} as record<Array<callback>>
+  protected static readonly listeners = {} as Record<PropertyKey, Array<Callback>>
 
   /** Listeners. */
   get #listeners() {
@@ -170,7 +170,7 @@ export class Resource<T extends model> {
   }
 
   /** Fetch back resource from {@link Store}. */
-  async #fetch(resolve: callback, reject: callback, id?: Nullable<id> | DeepPartial<T>) {
+  async #fetch(resolve: Callback, reject: Callback, id?: Nullable<id> | DeepPartial<T>) {
     try {
       if (typeof id === "string") {
         this.#data = { ...this.#data, id } as T
@@ -362,13 +362,13 @@ export class Resource<T extends model> {
   }
 
   /** Instantiate a new {@link Resource} constructor with specified {@link Store}, {@link Logger}, listeners and initialization function. */
-  static with<U extends shape, V extends record, W extends record, T extends typeof Resource<model_extended<U>>, Z extends typeof Resource<rw>, X = T & Z & { ready: Promise<T & Z & { bound: V & W }>; bound: V & W }>(
+  static with<U extends shape, V extends Record<PropertyKey, unknown>, W extends Record<PropertyKey, unknown>, T extends typeof Resource<model_extended<U>>, Z extends typeof Resource<rw>, X = T & Z & { ready: Promise<T & Z & { bound: V & W }>; bound: V & W }>(
     this: Z,
     { store = this.store, name = this.name, log = this.log, listeners = {}, init = () => Promise.resolve(), model: _model = is.object({} as U), bind }: {
       store?: Store
       name?: string
       log?: Nullable<Logger>
-      listeners?: record<Arrayable<callback>>
+      listeners?: Record<PropertyKey, Arrayable<Callback>>
       init?: (_: T) => Promise<unknown>
       model?: is.ZodObject<U>
       bind?: V
diff --git a/orm/store/kv.ts b/orm/store/kv.ts
@@ -1,5 +1,5 @@
 // Imports
-import type { callback, Nullable, Promisable, record, rw } from "@libs/typing"
+import type { Callback, Nullable, Promisable, rw } from "@libs/typing"
 import { Store as _Store } from "./store.ts"
 import type { key, version } from "./store.ts"
 
@@ -54,9 +54,9 @@ export class Store extends _Store {
   }
 
   /** List entries from {@link Store}. */
-  protected _list<T extends record>(key: key | [key, key], { limit, reverse }: { limit?: number; reverse?: boolean }, array: boolean): Promisable<Array<{ key: key; value: T; version: version }> | AsyncGenerator<{ key: key; value: T; version: version }>> {
+  protected _list<T extends Record<PropertyKey, unknown>>(key: key | [key, key], { limit, reverse }: { limit?: number; reverse?: boolean }, array: boolean): Promisable<Array<{ key: key; value: T; version: version }> | AsyncGenerator<{ key: key; value: T; version: version }>> {
     let list: Deno.KvListIterator<T>
-    let last = null as Nullable<callback>
+    let last = null as Nullable<Callback>
     if ((Array.isArray(key[0])) && (Array.isArray(key[1]))) {
       const [start, end] = key
       list = this.#kv.list<T>({ start, end }, { limit, reverse })
diff --git a/orm/store/store.ts b/orm/store/store.ts
@@ -1,7 +1,7 @@
 // Imports
 import { Logger } from "@libs/logger"
-import type { Nullable, Promisable, record } from "@libs/typing"
-export type { Promisable, record }
+import type { Nullable, Promisable } from "@libs/typing"
+export type { Promisable }
 
 /**
  * Key-Value store.
@@ -13,7 +13,7 @@ export abstract class Store {
   constructor({ log = new Logger(), ...options }: { log?: Logger } = {}) {
     const { promise, resolve, reject } = Promise.withResolvers<this>()
     this.ready = promise
-    this.options = options as record
+    this.options = options as Record<PropertyKey, unknown>
     this.#log = log
     this.#init(resolve, reject)
   }
@@ -22,7 +22,7 @@ export abstract class Store {
   readonly ready: Promise<this>
 
   /** Options. */
-  protected readonly options: record
+  protected readonly options: Record<PropertyKey, unknown>
 
   /** {@link Logger}. */
   readonly #log
@@ -112,19 +112,26 @@ export abstract class Store {
   protected abstract _delete(keys: key[], versionstamp: Nullable<version>): Promisable<{ ok: boolean }>
 
   /** List entries from {@link Store}. */
-  async list<T extends record>(key: key | [key, key], options?: { limit?: number; reverse?: boolean; array: true }): Promise<Array<{ key: key; value: T; version: version }>>
+  async list<T extends Record<PropertyKey, unknown>>(key: key | [key, key], options?: { limit?: number; reverse?: boolean; array: true }): Promise<Array<{ key: key; value: T; version: version }>>
   /** List entries from {@link Store}. */
-  async list<T extends record>(key: key | [key, key], options?: { limit?: number; reverse?: boolean; array?: false }): Promise<AsyncGenerator<{ key: key; value: T; version: version }>>
+  async list<T extends Record<PropertyKey, unknown>>(key: key | [key, key], options?: { limit?: number; reverse?: boolean; array?: false }): Promise<AsyncGenerator<{ key: key; value: T; version: version }>>
   /** List entries from {@link Store}. */
-  async list<T extends record>(key: key | [key, key], { limit, reverse, array = true }: { limit?: number; reverse?: boolean; array?: boolean } = {}): Promise<Array<{ key: key; value: T; version: version }> | AsyncGenerator<{ key: key; value: T; version: version }>> {
+  async list<T extends Record<PropertyKey, unknown>>(
+    key: key | [key, key],
+    { limit, reverse, array = true }: { limit?: number; reverse?: boolean; array?: boolean } = {},
+  ): Promise<Array<{ key: key; value: T; version: version }> | AsyncGenerator<{ key: key; value: T; version: version }>> {
     await this.ready
     const list = this._list<T>(key, { limit, reverse }, array)
     this.#log.with({ op: "list", key: f(key), limit, reverse, array }).trace()
     return list
   }
 
   /** List entries from {@link Store}. This method is intended to be implemented by child classes. */
-  protected abstract _list<T extends record>(key: key | [key, key], { limit, reverse }: { limit?: number; reverse?: boolean }, array: boolean): Promisable<Array<{ key: key; value: T; version: version }> | AsyncGenerator<{ key: key; value: T; version: version }>>
+  protected abstract _list<T extends Record<PropertyKey, unknown>>(
+    key: key | [key, key],
+    { limit, reverse }: { limit?: number; reverse?: boolean },
+    array: boolean,
+  ): Promisable<Array<{ key: key; value: T; version: version }> | AsyncGenerator<{ key: key; value: T; version: version }>>
 }
 
 /** {@link Store} entry's key. */
diff --git a/package.json b/package.json
@@ -26,7 +26,7 @@
     "xml"
   ],
   "dependencies": {
-    "@std/cli": "npm:@jsr/std__cli@^1.0.21",
+    "@std/cli": "npm:@jsr/std__cli@^1.0.22",
     "@std/fmt": "npm:@jsr/std__fmt@^1.0.8",
     "@std/jsonc": "npm:@jsr/std__jsonc@^1.0.2",
     "@std/path": "npm:@jsr/std__path@^1.1.2"
diff --git a/reactive/context.ts b/reactive/context.ts
diff --git a/testing/_testing/deno.ts b/testing/_testing/deno.ts
diff --git a/testing/expect.ts b/testing/expect.ts
diff --git a/typing/types.ts b/typing/types.ts
diff --git a/xml/bench/bench.ts b/xml/bench/bench.ts

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-// deno-lint-ignore-file no-external-import`
	`1`	`+// deno-lint-ignore-file no-external-import no-import-prefix`
`2`	`2`	`// Imports`
`3`	`3`	`import { expandGlob } from "jsr:@std/fs@^1.0.19"`
`4`	`4`	`import { basename, dirname, fromFileUrl, resolve } from "@std/path"`