@eik/common 4.0.8 → 4.0.9

package/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [4.0.9](https://github.com/eik-lib/common/compare/v4.0.8...v4.0.9) (2024-08-13)
+
+
+### Bug Fixes
+
+* add jsdoc for schema validators ([#325](https://github.com/eik-lib/common/issues/325)) ([062446a](https://github.com/eik-lib/common/commit/062446a1fa91cf0f1a63078b087a3670815b134c))
+
 ## [4.0.8](https://github.com/eik-lib/common/compare/v4.0.7...v4.0.8) (2024-08-12)
 
 

package/README.md

@@ -1,149 +1,72 @@
-# Eik Common
+# @eik/common
 
-This package contains common utilities and schemas
+This package contains common utilities and schemas used in other Eik modules.
 
-## ESM ONLY
+## Schema
 
-From v4, this module is ESM only and cannot be used with Common JS.
+The [schema for `eik.json`](https://eik.dev/docs/reference/eik-json#json-schema)
+can be found here in this repo. Here is how you can use it in your `eik.json`.
 
-## APIs
-
-### schemas
-
-#### eik.json
-
-Importing schemas
-
-```js
-import { schemas, assert } from '@eik/common';
-```
-
-Validating an `eik.json` file
-
-```js
-const { error, value } = schemas.validate.eikJSON({
-    name: 'my-app',
-    version: '1.0.0',
-    server: 'http://eik-server',
-    files: [],
-});
-
-//or
-
-assert.eikJSON({
-    name: 'my-app',
-    version: '1.0.0',
-    server: 'http://eik-server',
-    files: [],
-});
-```
-
-Using individual schema validators
-
-##### name
-
-```js
-const { error, value } = schemas.validate.name('my-app');
-
-// or
-
-assert.name('my-app');
-```
-
-##### version
-
-```js
-const { error, value } = schemas.validate.version('1.0.0');
-
-// or
-
-assert.version('1.0.0');
-```
-
-##### type
-
-```js
-const { error, value } = schemas.validate.type('package');
-
-// or
-
-assert.type('package');
+```json
+{
+    "$schema": "https://raw.githubusercontent.com/eik-lib/common/main/lib/schemas/eikjson.schema.json",
+    "name": "my-app",
+    "version": "1.0.0",
+    "server": "https://eik.store.com",
+    "files": "./public",
+    "import-map": ["https://eik.store.com/map/store/v1"]
+}
 ```
 
-##### server
+`@eik/common` has a JavaScript API to [check against the schema](#schemas).
 
-```js
-const { error, value } = schemas.validate.server('http://myeikserver.com');
-
-// or
+## API
 
-assert.server('http://myeikserver.com');
-```
+### helpers
 
-##### files
+`helpers` has utility functions used by several other Eik modules.
 
 ```js
-const { error, value } = schemas.validate.files({
-    './index.js': '/path/to/file.js',
-});
-
-// or
+import { helpers } from '@eik/common';
 
-assert.files({
-    './index.js': '/path/to/file.js',
-});
+let config = helpers.getDefaults();
 ```
 
-##### import map
+These are the available functions on `helpers`.
+
+| Name                  | Description                                                                                                                                                                                      |
+| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `getDefaults`         | Reads configuration from `eik.json` or `package.json`. Includes defaults for missing optional settings.                                                                                          |
+| `localAssets`         | Sets up asset routes for local development. Mounted paths match those on Eik server and values are read from projects eik.json file.                                                             |
+| `typeSlug`            | Maps between Eik configuration values for the package type and its URL/file system value.                                                                                                        |
+| `typeTitle`           | Maps between a type config value and its title. Essentially uppercases the input.                                                                                                                |
+| `addTrailingSlash`    |                                                                                                                                                                                                  |
+| `removeTrailingSlash` |                                                                                                                                                                                                  |
+| `addLeadingSlash`     |                                                                                                                                                                                                  |
+| `removeLeadingSlash`  |                                                                                                                                                                                                  |
+| `resolveFiles`        | Uses an Eik JSON "files" definition to resolve files on disk into a data structure. Returns a list of [ResolvedFile](https://github.com/eik-lib/common/blob/main/lib/classes/resolved-files.js). |
+| `configStore`         | Collection of helper methods for reading and writing Eik configuration files.                                                                                                                    |
 
-```js
-const { error, value } = schemas.validate.importMap(
-    'http://meserver.com/map.json',
-);
-
-const { error, value } = schemas.validate.importMap([
-    'http://meserver.com/map1.json',
-    'http://meserver.com/map2.json',
-]);
-
-// or
+#### localAssets
 
-assert.importMap([
-    'http://meserver.com/map1.json',
-    'http://meserver.com/map2.json',
-]);
-```
+Sets up asset routes for local development. Mounted paths match those on Eik server and values are read from projects eik.json file.
 
-##### out
+Given this server and `eik.json`, the following routes would be added to your app.
 
 ```js
-const { error, value } = schemas.validate.out('./.eik');
-
-// or
-
-assert.out('./.eik');
-```
-
-### helpers
-
-#### localAssets
+import { helpers } from '@eik/common';
+import express from 'express';
 
-A function to help development by mounting development routes to an Express.js or Fastify app based on values defined in `eik.json`
+let app = express();
 
-```js
-import express from 'express';
-import { helpers } from '@eik/common';
-const app = express();
 await helpers.localAssets(app);
 ```
 
-For an `eik.json` file such as
-
 ```json
 {
     "name": "my-app",
     "version": "1.0.0",
-    "server": "https://assets.myeikserver.com",
+    "server": "https://eik.store.com",
     "files": {
         "esm.js": "./assets/esm.js",
         "esm.css": "./assets/esm.css",
@@ -152,8 +75,6 @@ For an `eik.json` file such as
 }
 ```
 
-A number of routes would be mounted into your app.
-
 ```
 /pkg/my-app/1.0.0/esm.js
 /pkg/my-app/1.0.0/esm.css
@@ -161,30 +82,81 @@ A number of routes would be mounted into your app.
 /pkg/my-app/1.0.0/esm.css.map
 ```
 
-#### packageURL
+### schemas
 
-This helper function can be used to build URLs for given entries in an `eik.json` files section.
+`schemas` has functions to check values against the [`eik.json` schema](#schema).
+You can check a value against the schema for `eik.json` as a whole, or for individual
+values in the schema.
 
-Given the following `eik.json` file:
+```js
+import { schemas } from '@eik/common';
 
-```json
-{
-    "name": "my-app",
-    "version": "1.0.0",
-    "server": "https://assets.myeikserver.com",
-    "files": {
-        "esm.js": "./assets/esm.js",
-        "esm.css": "./assets/esm.css",
-        "/": "./assets/**/*.map"
-    }
+let { error, value } = schemas.validate.eikJSON(eikConfig);
+if (error) {
+    // fallback
 }
 ```
 
-and the following call to packageURL
+If you prefer, you can use the `assert` API which throws on error.
 
 ```js
-import { helpers } from '@eik/common';
-const url = await helpers.packageURL('esm.js');
+import { schemas } from '@eik/common';
+
+try {
+    schemas.assert.eikJSON(eikConfig);
+} catch {
+    // fallback
+}
+```
+
+These are the available functions on `schemas.validate` and `schemas.assert`.
+
+| Name        | Description                                                             |
+| ----------- | ----------------------------------------------------------------------- |
+| `eikJSON`   | Checks that the given value includes required fields that are valid     |
+| `name`      | Checks [name](https://eik.dev/docs/reference/eik-json#name)             |
+| `version`   | Checks [version](https://eik.dev/docs/reference/eik-json#version)       |
+| `type`      | Checks [type](https://eik.dev/docs/reference/eik-json#type)             |
+| `server`    | Checks [server](https://eik.dev/docs/reference/eik-json#server)         |
+| `files`     | Checks [files](https://eik.dev/docs/reference/eik-json#files)           |
+| `importMap` | Checks [import-map](https://eik.dev/docs/reference/eik-json#import-map) |
+| `out`       | Checks [out](https://eik.dev/docs/reference/eik-json#out)               |
+
+### stream
+
+`stream` has functions to check that a value is a Stream.
+
+```js
+import { stream } from '@eik/common';
+
+if (stream.isStream(maybeStream)) {
+    // yup, it's a Stream
+}
+
+if (stream.isReadableStream(maybeReadableStream)) {
+    // yup, it's a ReadableStream
+}
+```
+
+### validators
+
+`validators` functions return the provided string normalized to lowercase, or throw an Error if the value does not pass the validation rules.
+Where possible, prefer using the [`schemas` API](#schemas).
+
+```js
+import { validators } from '@eik/common';
+
+let alias = validators.alias('1');
 ```
 
-The URL returned will be `https://assets.myeikserver.com/pkg/my-app/1.0.0/esm.js`
+These are the available functions on `validators`.
+
+| Name         | Description                                                      |
+| ------------ | ---------------------------------------------------------------- |
+| `alias`      | Checks that a value is a valid alias value (ex 1)                |
+| `name`       | Checks that a value is a valid package name                      |
+| `org`        | Checks that a value is a valid organisation name.                |
+| `origin`     | Check that a value looks like an HTTP origin.                    |
+| `version`    | Checks that a value is a valid semver version                    |
+| `semverType` | Checks that a value is a valid semver type (major, minor, patch) |
+| `type`       | Checks that the value is a valid Eik type (pkg, npm, map)        |

package/lib/helpers/type-slug.js

@@ -1,7 +1,8 @@
-// @ts-check
-
 /**
- * @type {(type: string) => string}
+ * Maps between Eik configuration values for the package type and its URL/file system value.
+ * Essentially `package` -> `pkg`.
+ * @param {string} type
+ * @returns {string} the Eik package type
  */
 export default (type) => {
     if (type === 'package') return 'pkg';

package/lib/helpers/type-title.js

@@ -1,7 +1,7 @@
-// @ts-check
-
 /**
- * @type {(type: string) => string}
+ * Maps between a type config value and its title. Essentially uppercases the input.
+ * @param {string} type
+ * @param {"PACKAGE" | "NPM" | "MAP"} type
  */
 export default (type) => {
     if (type === 'package') return 'PACKAGE';

package/lib/schemas/assert.js

@@ -1,4 +1,3 @@
-// @ts-check
 import {
     eikJSON,
     name,
@@ -11,7 +10,20 @@ import {
 } from './validate.js';
 import ValidationError from './validation-error.js';
 
-// @ts-ignore
+/**
+ * @template T
+ * @callback SchemaAssert
+ * @param {T} value
+ * @returns {void}
+ * @throws {ValidationError} if validation fails
+ */
+
+/**
+ * @template T
+ * @param {import('./validate.js').SchemaValidator<T>} validate
+ * @param {string} message
+ * @returns {SchemaAssert<T>}
+ */
 const assert = (validate, message) => (value) => {
     const valid = validate(value);
     if (valid.error) {
@@ -25,17 +37,26 @@ const assert = (validate, message) => (value) => {
                 return msg;
             })
             .join(',');
+        // @ts-expect-error Maybe some toString magic happens here?
         throw new ValidationError(`${message}: ${errorMessage}`, valid.error);
     }
 };
 
 export default {
+    /** Asserts the given [eik.json](https://eik.dev/docs/reference/eik-json) includes required fields that are valid */
     eikJSON: assert(eikJSON, 'Invalid eik.json schema'),
+    /** Asserts the given [name](https://eik.dev/docs/reference/eik-json#name) value is valid*/
     name: assert(name, 'Parameter "name" is not valid'),
+    /** Asserts the given [type](https://eik.dev/docs/reference/eik-json#type) value is valid*/
     type: assert(type, 'Parameter "type" is not valid'),
+    /** Asserts the given [version](https://eik.dev/docs/reference/eik-json#version) value is valid*/
     version: assert(version, 'Parameter "version" is not valid'),
+    /** Asserts the given [server](https://eik.dev/docs/reference/eik-json#server) value is valid*/
     server: assert(server, 'Parameter "server" is not valid'),
+    /** Asserts the given [files](https://eik.dev/docs/reference/eik-json#files) value is valid  */
     files: assert(files, 'Parameter "files" is not valid'),
+    /** Asserts the given [import-map](https://eik.dev/docs/reference/eik-json#import-map) value is valid  */
     importMap: assert(importMap, 'Parameter "import-map" is not valid'),
+    /** Asserts the given [out](https://eik.dev/docs/reference/eik-json#out) value is valid  */
     out: assert(out, 'Parameter "out" is not valid'),
 };

package/lib/schemas/validate.js

@@ -13,7 +13,24 @@ const eikJSONSchema = JSON.parse(
     readFileSync(join(__dirname, './eikjson.schema.json'), 'utf8'),
 );
 
-// @ts-ignore
+/**
+ * @typedef {import('ajv').ErrorObject & { dataPath?: string }} ErrorObject
+ */
+
+/**
+ * @template [T=unknown]
+ * @callback SchemaValidator
+ * @param {T} data
+ * @returns {{ value: T; error: false | import('ajv').ErrorObject[]}}
+ */
+
+/**
+ * Create a validator for the schema using {@link Ajv}
+ * @template [T=unknown]
+ * @param {unknown} schema
+ * @param {import('ajv').Options} [ajvOptions]
+ * @returns {SchemaValidator<T>}
+ */
 const createValidator = (schema, ajvOptions) => {
     // @ts-ignore
     const ajv = new Ajv(ajvOptions);
@@ -21,7 +38,6 @@ const createValidator = (schema, ajvOptions) => {
     formats(ajv); // Needed to support "uri"
     const validate = ajv.compile(schema);
 
-    // @ts-ignore
     return (data) => {
         const cloned = JSON.parse(JSON.stringify(data));
         const valid = validate(cloned);
@@ -29,20 +45,30 @@ const createValidator = (schema, ajvOptions) => {
     };
 };
 
+/**
+ * Checks that the given value includes required fields that are valid
+ * @type {SchemaValidator<import('../../eikjson.js').EikjsonSchema>}
+ */
 const eikJSON = createValidator(eikJSONSchema, {
     removeAdditional: true,
     useDefaults: true,
 });
-// @ts-ignore
+
+/**
+ * @param {SchemaValidator<string>} jsonSchemaValidator
+ * @returns {SchemaValidator<string>}
+ */
 const createNameValidator = (jsonSchemaValidator) => (value) => {
     const result = jsonSchemaValidator(value);
     if (!result.error) {
         const pkvalid = npmPkg(value);
+        /** @type {ErrorObject[]} */
         const errors = [];
         if (!pkvalid.validForNewPackages) {
             errors.push({
                 keyword: 'validForNewPackages',
-                dataPath: '.name',
+                instancePath: '.name',
+                dataPath: '.name', // this was here before, but maybe replaced by instancePath?
                 schemaPath: '',
                 params: [],
                 message: 'should be valid package name',
@@ -54,15 +80,21 @@ const createNameValidator = (jsonSchemaValidator) => (value) => {
     }
     return result;
 };
-// @ts-ignore
+
+/**
+ * @param {SchemaValidator<string>} jsonSchemaValidator
+ * @returns {SchemaValidator<string>}
+ */
 const createVersionValidator = (jsonSchemaValidator) => (value) => {
     const result = jsonSchemaValidator(value);
     if (!result.error) {
         const version = semver.valid(value);
+        /** @type {ErrorObject[]} */
         const errors = [];
         if (!version) {
             errors.push({
                 keyword: 'invalidSemverRange',
+                instancePath: '.version',
                 dataPath: '.version',
                 schemaPath: '',
                 params: [],
@@ -76,16 +108,50 @@ const createVersionValidator = (jsonSchemaValidator) => (value) => {
     return result;
 };
 
+/**
+ * Checks [name](https://eik.dev/docs/reference/eik-json#name)
+ * @type {SchemaValidator<string>}
+ */
 const name = createNameValidator(
     createValidator(eikJSONSchema.properties.name),
 );
+
+/**
+ * Checks [version](https://eik.dev/docs/reference/eik-json#version)
+ * @type {SchemaValidator<string>}
+ */
 const version = createVersionValidator(
     createValidator(eikJSONSchema.properties.version),
 );
+
+/**
+ * Checks [type](https://eik.dev/docs/reference/eik-json#type)
+ * @type {SchemaValidator<string>}
+ */
 const type = createValidator(eikJSONSchema.properties.type);
+
+/**
+ * Checks [server](https://eik.dev/docs/reference/eik-json#server)
+ * @type {SchemaValidator<string>}
+ */
 const server = createValidator(eikJSONSchema.properties.server);
+
+/**
+ * Checks [files](https://eik.dev/docs/reference/eik-json#files)
+ * @type {SchemaValidator<string | Record<string, string>>}
+ */
 const files = createValidator(eikJSONSchema.properties.files);
+
+/**
+ * Checks [import-map](https://eik.dev/docs/reference/eik-json#import-map)
+ * @type {SchemaValidator<string | string[]>}
+ */
 const importMap = createValidator(eikJSONSchema.properties['import-map']);
+
+/**
+ * Checks [out](https://eik.dev/docs/reference/eik-json#out)
+ * @type {SchemaValidator<string>}
+ */
 const out = createValidator(eikJSONSchema.properties.out);
 
 export { eikJSON, name, version, type, server, files, importMap, out };

package/lib/stream.js

@@ -1,12 +1,24 @@
-// @ts-ignore
+/**
+ * Checks if the value is a Stream
+ * @param {unknown} stream
+ * @returns {boolean}
+ */
 export const isStream = (stream) =>
     stream !== null &&
     typeof stream === 'object' &&
+    // @ts-expect-error
     typeof stream.pipe === 'function';
 
-// @ts-ignore
+/**
+ * Checks if the value is a {@link ReadableStream}
+ * @param {unknown} stream
+ * @returns {boolean}
+ */
 export const isReadableStream = (stream) =>
     isStream(stream) &&
+    // @ts-expect-error
     stream.readable !== false &&
+    // @ts-expect-error
     typeof stream._read === 'function' &&
+    // @ts-expect-error
     typeof stream._readableState === 'object';

package/lib/validators/index.js

@@ -2,7 +2,13 @@ import semver from 'semver';
 import npmPkg from 'validate-npm-package-name';
 
 const urlIsh = /^https?:\/\/[a-zA-Z0-9-_./]+(:[0-9]+)?/;
-// @ts-ignore
+
+/**
+ * Check that a value looks like an HTTP origin.
+ * @param {string} value
+ * @returns {string} the value in lowercase
+ * @throws {Error} if the parameter does not match a URL pattern
+ */
 export const origin = (value) => {
     if (urlIsh.test(value)) {
         return value.toLowerCase();
@@ -10,7 +16,12 @@ export const origin = (value) => {
     throw new Error('Parameter "origin" is not valid');
 };
 
-// @ts-ignore
+/**
+ * Checks that a value is a valid organisation name.
+ * @param {string} value
+ * @returns {string} the value in lowercase
+ * @throws {Error} if the value is not a valid organisation name
+ */
 export const org = (value) => {
     if (/^[a-zA-Z0-9_-]+$/.test(value)) {
         return value.toLowerCase();
@@ -18,7 +29,12 @@ export const org = (value) => {
     throw new Error(`Parameter "org" is not valid - Value: ${value}`);
 };
 
-// @ts-ignore
+/**
+ * Checks that a value is a valid package name.
+ * @param {string} value
+ * @returns {string} the value in lowercase
+ * @throws {Error} if the value is not a valid package name
+ */
 export const name = (value) => {
     const result = npmPkg(value);
     if (result.validForNewPackages || result.validForOldPackages) {
@@ -27,7 +43,12 @@ export const name = (value) => {
     throw new Error(`Parameter "name" is not valid - Value: ${value}`);
 };
 
-// @ts-ignore
+/**
+ * Checks that a value is a valid semver version.
+ * @param {string} value
+ * @returns {string} the value in lowercase
+ * @throws {Error} if the value is not a valid semver version
+ */
 export const version = (value) => {
     const result = semver.valid(value);
     if (result) {
@@ -36,7 +57,12 @@ export const version = (value) => {
     throw new Error(`Parameter "version" is not valid - Value: ${value}`);
 };
 
-// @ts-ignore
+/**
+ * Checks that a value is a valid alias value.
+ * @param {string} value
+ * @returns {string} the value in lowercase
+ * @throws {Error} if the value is not a valid alias value
+ */
 export const alias = (value) => {
     if (/^[0-9]+$/.test(value)) {
         return value;
@@ -44,7 +70,12 @@ export const alias = (value) => {
     throw new Error(`Parameter "alias" is not valid - Value: ${value}`);
 };
 
-// @ts-ignore
+/**
+ * Checks that a value is a valid Eik package type.
+ * @param {string} value
+ * @returns {string} the value in lowercase
+ * @throws {Error} if the value is not a valid Eik package type
+ */
 export const type = (value) => {
     if (value === 'pkg' || value === 'map' || value === 'npm') {
         return value;
@@ -52,11 +83,21 @@ export const type = (value) => {
     throw new Error(`Parameter "type" is not valid - Value: ${value}`);
 };
 
-// TODO; https://github.com/asset-pipe/core/issues/12
-// @ts-ignore
+/**
+ * No-op, returning its value.
+ * @param {string} value
+ * @returns {string} the value
+ * @todo https://github.com/asset-pipe/core/issues/12
+ * @todo Can we remove this?
+ */
 export const extra = (value) => value;
 
-// @ts-ignore
+/**
+ * Checks that a value is a valid semver type (major, minor, patch).
+ * @param {string} value
+ * @returns {string} the value
+ * @throws {Error} if the value is not a valid semver type
+ */
 export const semverType = (value) => {
     if (value === 'major' || value === 'minor' || value === 'patch') {
         return value;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eik/common",
-  "version": "4.0.8",
+  "version": "4.0.9",
   "description": "Common utilities for Eik modules",
   "main": "lib/index.js",
   "types": "types/index.d.ts",

package/types/helpers/type-slug.d.ts

@@ -1,2 +1,2 @@
-declare const _default: (type: string) => string;
+declare function _default(type: string): string;
 export default _default;

package/types/helpers/type-title.d.ts

@@ -1,2 +1,2 @@
-declare const _default: (type: string) => string;
+declare function _default(type: string): "PACKAGE" | "NPM" | "MAP";
 export default _default;

package/types/schemas/assert.d.ts

@@ -1,11 +1,12 @@
 declare namespace _default {
-    function eikJSON(value: any): void;
-    function name(value: any): void;
-    function type(value: any): void;
-    function version(value: any): void;
-    function server(value: any): void;
-    function files(value: any): void;
-    function importMap(value: any): void;
-    function out(value: any): void;
+    function eikJSON(value: import("../../eikjson.js").EikjsonSchema): void;
+    function name(value: string): void;
+    function type(value: string): void;
+    function version(value: string): void;
+    function server(value: string): void;
+    function files(value: string | Record<string, string>): void;
+    function importMap(value: string | string[]): void;
+    function out(value: string): void;
 }
 export default _default;
+export type SchemaAssert<T> = (value: T) => void;

package/types/schemas/validate.d.ts

@@ -1,26 +1,47 @@
-export function eikJSON(data: any): {
-    value: any;
-    error: any;
+export type ErrorObject = import("ajv").ErrorObject & {
+    dataPath?: string;
 };
-export function name(value: any): any;
-export function version(value: any): any;
-export function type(data: any): {
-    value: any;
-    error: any;
-};
-export function server(data: any): {
-    value: any;
-    error: any;
-};
-export function files(data: any): {
-    value: any;
-    error: any;
-};
-export function importMap(data: any): {
-    value: any;
-    error: any;
-};
-export function out(data: any): {
-    value: any;
-    error: any;
+export type SchemaValidator<T = unknown> = (data: T) => {
+    value: T;
+    error: false | import("ajv").ErrorObject[];
 };
+/**
+ * Checks that the given value includes required fields that are valid
+ * @type {SchemaValidator<import('../../eikjson.js').EikjsonSchema>}
+ */
+export const eikJSON: SchemaValidator<import("../../eikjson.js").EikjsonSchema>;
+/**
+ * Checks [name](https://eik.dev/docs/reference/eik-json#name)
+ * @type {SchemaValidator<string>}
+ */
+export const name: SchemaValidator<string>;
+/**
+ * Checks [version](https://eik.dev/docs/reference/eik-json#version)
+ * @type {SchemaValidator<string>}
+ */
+export const version: SchemaValidator<string>;
+/**
+ * Checks [type](https://eik.dev/docs/reference/eik-json#type)
+ * @type {SchemaValidator<string>}
+ */
+export const type: SchemaValidator<string>;
+/**
+ * Checks [server](https://eik.dev/docs/reference/eik-json#server)
+ * @type {SchemaValidator<string>}
+ */
+export const server: SchemaValidator<string>;
+/**
+ * Checks [files](https://eik.dev/docs/reference/eik-json#files)
+ * @type {SchemaValidator<string | Record<string, string>>}
+ */
+export const files: SchemaValidator<string | Record<string, string>>;
+/**
+ * Checks [import-map](https://eik.dev/docs/reference/eik-json#import-map)
+ * @type {SchemaValidator<string | string[]>}
+ */
+export const importMap: SchemaValidator<string | string[]>;
+/**
+ * Checks [out](https://eik.dev/docs/reference/eik-json#out)
+ * @type {SchemaValidator<string>}
+ */
+export const out: SchemaValidator<string>;

package/types/stream.d.ts

@@ -1,2 +1,2 @@
-export function isStream(stream: any): boolean;
-export function isReadableStream(stream: any): boolean;
+export function isStream(stream: unknown): boolean;
+export function isReadableStream(stream: unknown): boolean;

package/types/validators/index.d.ts

@@ -1,8 +1,8 @@
-export function origin(value: any): any;
-export function org(value: any): any;
-export function name(value: any): any;
-export function version(value: any): string;
-export function alias(value: any): any;
-export function type(value: any): any;
-export function extra(value: any): any;
-export function semverType(value: any): any;
+export function origin(value: string): string;
+export function org(value: string): string;
+export function name(value: string): string;
+export function version(value: string): string;
+export function alias(value: string): string;
+export function type(value: string): string;
+export function extra(value: string): string;
+export function semverType(value: string): string;