@wener/common 1.0.3 → 1.0.5

package/src/jsonschema/types.d.ts

@@ -1,173 +1,163 @@
 type JsonSchemaTypeName =
-  | 'string' //
-  | 'number'
-  | 'integer'
-  | 'boolean'
-  | 'object'
-  | 'array'
-  | 'null';
+	| 'string' //
+	| 'number'
+	| 'integer'
+	| 'boolean'
+	| 'object'
+	| 'array'
+	| 'null';
 
 type JsonValue =
-  | string //
-  | number
-  | boolean
-  | {
-      [key: string]: JsonValue;
-    }
-  | JsonValue[]
-  | null;
+	| string //
+	| number
+	| boolean
+	| { [key: string]: JsonValue }
+	| JsonValue[]
+	| null;
 
 type JsonSchemaVersion =
-  | 'http://json-schema.org/schema' // latest
-  | 'https://json-schema.org/draft/2020-12/schema'
-  // draft-07
-  | 'http://json-schema.org/draft-07/schema#' //
-  | 'http://json-schema.org/draft-07/hyper-schema#';
+	| 'http://json-schema.org/schema' // latest
+	| 'https://json-schema.org/draft/2020-12/schema'
+	// draft-07
+	| 'http://json-schema.org/draft-07/schema#' //
+	| 'http://json-schema.org/draft-07/hyper-schema#';
 
 type JsonSchemaFormatName =
-  //
-  | 'date-time'
-  | 'date'
-  | 'time'
-  | 'duration'
-  //
-  | 'email'
-  | 'idn-email'
-  //
-  | 'hostname'
-  | 'idn-hostname'
-  | 'ipv4'
-  | 'ipv6'
-  //
-  | 'uri'
-  | 'uri-reference'
-  | 'iri'
-  | 'iri-reference'
-  | 'uuid'
-  | 'uri-template'
-  | 'regex'
-  | 'json-pointer'
-  | 'relative-json-pointer';
+	//
+	| 'date-time'
+	| 'date'
+	| 'time'
+	| 'duration'
+	//
+	| 'email'
+	| 'idn-email'
+	//
+	| 'hostname'
+	| 'idn-hostname'
+	| 'ipv4'
+	| 'ipv6'
+	//
+	| 'uri'
+	| 'uri-reference'
+	| 'iri'
+	| 'iri-reference'
+	| 'uuid'
+	| 'uri-template'
+	| 'regex'
+	| 'json-pointer'
+	| 'relative-json-pointer';
 
 export type JsonSchemaDef = {
-  $id?: string;
-  $ref?: string;
-  /**
-   * Meta schema
-   *
-   * Recommended values:
-   * - 'http://json-schema.org/schema#'
-   * - 'http://json-schema.org/hyper-schema#'
-   * - 'http://json-schema.org/draft-07/schema#'
-   * - 'http://json-schema.org/draft-07/hyper-schema#'
-   *
-   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
-   */
-  $schema?: JsonSchemaVersion | string;
-  $comment?: string;
-
-  $defs?: {
-    [key: string]: JsonSchemaDef;
-  };
-
-  type?: JsonSchemaTypeName | JsonSchemaTypeName[];
-  enum?: JsonValue[];
-  const?: JsonValue;
-
-  //region Numeric Validation
-
-  multipleOf?: number;
-  maximum?: number;
-  exclusiveMaximum?: number;
-  minimum?: number;
-  exclusiveMinimum?: number;
-
-  //endregion
-
-  //region String Validation
-
-  maxLength?: number;
-  minLength?: number;
-  pattern?: string;
-
-  //endregion
-
-  //region Array Validation
-
-  items?: JsonSchemaDef | JsonSchemaDef[];
-  additionalItems?: JsonSchemaDef;
-  maxItems?: number;
-  minItems?: number;
-  uniqueItems?: boolean;
-  contains?: JsonSchemaDef;
-  //endregion
-
-  //region Object Validation
-
-  maxProperties?: number;
-  minProperties?: number;
-  required?: string[];
-  properties?: {
-    [key: string]: JsonSchemaDef;
-  };
-  patternProperties?: {
-    [key: string]: JsonSchemaDef;
-  };
-  additionalProperties?: JsonSchemaDef;
-  dependencies?: {
-    [key: string]: JsonSchemaDef | string[];
-  };
-  propertyNames?: JsonSchemaDef;
-  //endregion
-
-  //region Conditional
-
-  if?: JsonSchemaDef;
-  then?: JsonSchemaDef;
-  else?: JsonSchemaDef;
-
-  //endregion
-
-  //region Boolean Logic
-
-  allOf?: JsonSchemaDef[];
-  anyOf?: JsonSchemaDef[];
-  oneOf?: JsonSchemaDef[];
-  not?: JsonSchemaDef;
-  //endregion
-
-  //region Semantic
-
-  format?: JsonSchemaFormatName | string;
-
-  //endregion
-
-  //region String-Encoding Non-JSON Data
-
-  contentMediaType?: string;
-  contentEncoding?: string;
-  contentSchema?: JsonSchemaDef;
-  //endregion
-
-  /**
-   * use {@link $defs} instead
-   */
-  definitions?: Record<string, JsonSchemaDef>;
-
-  //region Meta-Data Annotations
-  /**
-   * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-10
-   */
-
-  title?: string;
-  description?: string;
-  default?: JsonValue;
-  readOnly?: boolean;
-  writeOnly?: boolean;
-  examples?: JsonValue;
-  deprecated?: boolean;
+	$id?: string;
+	$ref?: string;
+	/**
+	 * Meta schema
+	 *
+	 * Recommended values:
+	 * - 'http://json-schema.org/schema#'
+	 * - 'http://json-schema.org/hyper-schema#'
+	 * - 'http://json-schema.org/draft-07/schema#'
+	 * - 'http://json-schema.org/draft-07/hyper-schema#'
+	 *
+	 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-5
+	 */
+	$schema?: JsonSchemaVersion | string;
+	$comment?: string;
+
+	$defs?: { [key: string]: JsonSchemaDef };
+
+	type?: JsonSchemaTypeName | JsonSchemaTypeName[];
+	enum?: JsonValue[];
+	const?: JsonValue;
+
+	//region Numeric Validation
+
+	multipleOf?: number;
+	maximum?: number;
+	exclusiveMaximum?: number;
+	minimum?: number;
+	exclusiveMinimum?: number;
+
+	//endregion
+
+	//region String Validation
+
+	maxLength?: number;
+	minLength?: number;
+	pattern?: string;
+
+	//endregion
+
+	//region Array Validation
+
+	items?: JsonSchemaDef | JsonSchemaDef[];
+	additionalItems?: JsonSchemaDef;
+	maxItems?: number;
+	minItems?: number;
+	uniqueItems?: boolean;
+	contains?: JsonSchemaDef;
+	//endregion
+
+	//region Object Validation
+
+	maxProperties?: number;
+	minProperties?: number;
+	required?: string[];
+	properties?: { [key: string]: JsonSchemaDef };
+	patternProperties?: { [key: string]: JsonSchemaDef };
+	additionalProperties?: JsonSchemaDef;
+	dependencies?: { [key: string]: JsonSchemaDef | string[] };
+	propertyNames?: JsonSchemaDef;
+	//endregion
+
+	//region Conditional
+
+	if?: JsonSchemaDef;
+	then?: JsonSchemaDef;
+	else?: JsonSchemaDef;
+
+	//endregion
+
+	//region Boolean Logic
+
+	allOf?: JsonSchemaDef[];
+	anyOf?: JsonSchemaDef[];
+	oneOf?: JsonSchemaDef[];
+	not?: JsonSchemaDef;
+	//endregion
+
+	//region Semantic
+
+	format?: JsonSchemaFormatName | string;
+
+	//endregion
+
+	//region String-Encoding Non-JSON Data
+
+	contentMediaType?: string;
+	contentEncoding?: string;
+	contentSchema?: JsonSchemaDef;
+	//endregion
+
+	/**
+	 * use {@link $defs} instead
+	 */
+	definitions?: Record<string, JsonSchemaDef>;
+
+	//region Meta-Data Annotations
+	/**
+	 * @see https://tools.ietf.org/html/draft-handrews-json-schema-validation-01#section-10
+	 */
+
+	title?: string;
+	description?: string;
+	default?: JsonValue;
+	readOnly?: boolean;
+	writeOnly?: boolean;
+	examples?: JsonValue;
+	deprecated?: boolean;
 
-  //endregion
+	//endregion
 
-  nullable?: boolean;
+	nullable?: boolean;
 };

package/src/meta/defineFileType.tsx

@@ -1,68 +1,68 @@
 type DefineFileTypeOptions = {
-  name: string;
-  title?: string;
-  description?: string;
-  type?: string;
-  types?: string[];
-  extension?: string;
-  extensions?: string[];
-  tags?: string[];
-  metadata?: Record<string, any>;
+	name: string;
+	title?: string;
+	description?: string;
+	type?: string;
+	types?: string[];
+	extension?: string;
+	extensions?: string[];
+	tags?: string[];
+	metadata?: Record<string, any>;
 };
 export type FileTypeDef = {
-  name: string;
-  title: string;
-  description?: string;
-  type: string; // primary type
-  extension: string; // primary extension
-  types: string[];
-  extensions: string[];
-  tags: string[];
-  metadata: Record<string, any>;
+	name: string;
+	title: string;
+	description?: string;
+	type: string; // primary type
+	extension: string; // primary extension
+	types: string[];
+	extensions: string[];
+	tags: string[];
+	metadata: Record<string, any>;
 };
 
 let _all: FileTypeDef[] = [];
 
 export function defineFileType({
-  type = '',
-  types = [],
-  extension = '',
-  extensions = [],
-  ...opts
+	type = '',
+	types = [],
+	extension = '',
+	extensions = [],
+	...opts
 }: DefineFileTypeOptions): FileTypeDef {
-  if (!type) {
-    type = types[0] || '';
-  }
-  if (!extension) {
-    extension = extensions[0] || '';
-  }
-  if (!types.includes(type)) {
-    types = [type, ...types];
-  }
-  if (!extensions.includes(extension)) {
-    extensions = [extension, ...extensions];
-  }
+	if (!type) {
+		type = types[0] || '';
+	}
+	if (!extension) {
+		extension = extensions[0] || '';
+	}
+	if (!types.includes(type)) {
+		types = [type, ...types];
+	}
+	if (!extensions.includes(extension)) {
+		extensions = [extension, ...extensions];
+	}
 
-  const def: FileTypeDef = {
-    title: opts.title || opts.name,
-    type,
-    extension,
-    types,
-    extensions,
-    tags: [],
-    metadata: {},
-    ...opts,
-  };
-  let idx = _all.findIndex((v) => v.name === def.name);
-  if (idx >= 0) {
-    _all[idx] = def;
-    console.warn(`File type ${def.name} is redefined`);
-  } else {
-    _all.push(def);
-  }
-  return def;
+	const def: FileTypeDef = {
+		title: opts.title || opts.name,
+		type,
+		extension,
+		types,
+		extensions,
+		tags: [],
+		metadata: {},
+		...opts,
+	};
+	let idx = _all.findIndex((v) => v.name === def.name);
+	if (idx >= 0) {
+		_all[idx] = def;
+		console.warn(`File type ${def.name} is redefined`);
+	} else {
+		_all.push(def);
+	}
+	return def;
 }
 
 export function getFileType(): FileTypeDef[] {
-  return _all;
+	return _all;
 }

package/src/meta/defineInit.ts

@@ -1,68 +1,47 @@
 import type { MaybePromise } from '@wener/utils';
 import { startCase } from 'es-toolkit';
 
-type DefineInitOptions = {
-  name: string;
-  title?: string;
-  onInit?: () => any;
-  metadata?: Record<string, any>;
-};
-export type InitDef = {
-  name: string;
-  title: string;
-  onInit?: () => any;
-  metadata: Record<string, any>;
-};
+type DefineInitOptions = { name: string; title?: string; onInit?: () => any; metadata?: Record<string, any> };
+export type InitDef = { name: string; title: string; onInit?: () => any; metadata: Record<string, any> };
 let _all: InitDef[] = [];
 
 export function defineInit(o: DefineInitOptions) {
-  const def = {
-    title: startCase(o.name),
-    metadata: {},
-    ...o,
-  };
-  let idx = _all.findIndex((v) => v.name === def.name);
-  if (idx >= 0) {
-    console.warn(`skip redefined init: ${def.name}`);
-  } else {
-    _all.push(def);
-  }
+	const def = { title: startCase(o.name), metadata: {}, ...o };
+	let idx = _all.findIndex((v) => v.name === def.name);
+	if (idx >= 0) {
+		console.warn(`skip redefined init: ${def.name}`);
+	} else {
+		_all.push(def);
+	}
 
-  return def;
+	return def;
 }
 
 let result = new Map<any, MaybePromise<InitResult>>();
 
-type InitResult = {
-  name: string;
-  success: boolean;
-  error?: any;
-};
+type InitResult = { name: string; success: boolean; error?: any };
 
 export async function runInit(inits = _all) {
-  for (let init of inits) {
-    if (result.get(init)) {
-      return;
-    }
-    result.set(
-      init,
-      Promise.resolve().then(async () => {
-        let out: InitResult = {
-          name: init.name,
-          success: true,
-        };
-        try {
-          await init.onInit?.();
-        } catch (e) {
-          console.error(`Failed to init ${init.name}`, e);
-          out.success = false;
-          out.error = e;
-        }
-        result.set(init, out);
-        return out;
-      }),
-    );
-  }
+	for (let init of inits) {
+		if (result.get(init)) {
+			return;
+		}
+		result.set(
+			init,
+			Promise.resolve().then(async () => {
+				let out: InitResult = { name: init.name, success: true };
+				try {
+					await init.onInit?.();
+				} catch (e) {
+					console.error(`Failed to init ${init.name}`, e);
+					out.success = false;
+					out.error = e;
+				}
+				result.set(init, out);
+				return out;
+			}),
+		);
+	}
 
-  return Promise.all(result.values());
+	return Promise.all(result.values());
 }

package/src/meta/defineMetadata.test.ts

@@ -2,14 +2,12 @@ import { expect, test } from 'vitest';
 import { createMetadataKey, defineMetadata, getMetadata } from './defineMetadata';
 
 test('defineMetadata', () => {
-  const key = createMetadataKey<string>('name');
+	const key = createMetadataKey<string>('name');
 
-  const user = {
-    metadata: {},
-  };
+	const user = { metadata: {} };
 
-  defineMetadata(user, key, 'wener');
+	defineMetadata(user, key, 'wener');
 
-  expect(user.metadata).toEqual({ name: 'wener' });
-  expect(getMetadata(user, key)).toEqual('wener');
+	expect(user.metadata).toEqual({ name: 'wener' });
+	expect(getMetadata(user, key)).toEqual('wener');
 });

package/src/meta/defineMetadata.ts

@@ -1,70 +1,52 @@
 import { startCase } from 'es-toolkit';
 import { get, set } from 'es-toolkit/compat';
 
-type HasMetadata = {
-  metadata?: Record<string, any>;
-};
+type HasMetadata = { metadata?: Record<string, any> };
 
-type MetadataKey<T> = {
-  key: string;
-  type: T;
-  title: string;
-  description?: string;
-};
+type MetadataKey<T> = { key: string; type: T; title: string; description?: string };
 
 interface CreateMetadataKeyOptions {
-  key: string;
-  title?: string;
-  description?: string;
+	key: string;
+	title?: string;
+	description?: string;
 }
 
 export function createMetadataKey<T = never>(key: string, opts?: Omit<CreateMetadataKeyOptions, 'key'>): MetadataKey<T>;
 export function createMetadataKey<T = never>(opts: CreateMetadataKeyOptions): MetadataKey<T>;
 export function createMetadataKey<T = never>(a: any, b?: any): MetadataKey<T> {
-  const opts: CreateMetadataKeyOptions =
-    typeof a === 'string'
-      ? {
-          key: a,
-          ...b,
-        }
-      : a;
+	const opts: CreateMetadataKeyOptions = typeof a === 'string' ? { key: a, ...b } : a;
 
-  const { key } = opts;
-  opts.title ||= startCase(key);
+	const { key } = opts;
+	opts.title ||= startCase(key);
 
-  const k: MetadataKey<T> = {
-    ...opts,
-    type: null as any,
-  } as MetadataKey<T>;
+	const k: MetadataKey<T> = { ...opts, type: null as any } as MetadataKey<T>;
 
-  if ('toStringTag' in Symbol && typeof Symbol.toStringTag === 'symbol') {
-    Object.defineProperty(k, Symbol.toStringTag, {
-      value: key,
-    });
-  }
+	if ('toStringTag' in Symbol && typeof Symbol.toStringTag === 'symbol') {
+		Object.defineProperty(k, Symbol.toStringTag, { value: key });
+	}
 
-  return k;
+	return k;
 }
 
 export function defineMetadata<T>(res: HasMetadata, key: MetadataKey<T>, opts: T): void;
 export function defineMetadata<T>(key: MetadataKey<T>, items: Array<[HasMetadata, T]>): void;
 export function defineMetadata<T>(a: any, b: any, c?: any) {
-  if (Array.isArray(b)) {
-    const key = a;
-    const items = b;
-    for (const [res, opts] of items) {
-      defineMetadata(res, key, opts);
-    }
-  } else {
-    const res = a;
-    const key = b;
-    const opts = c;
-    res.metadata = res.metadata || {};
-    set(res.metadata, key.key, opts);
-  }
+	if (Array.isArray(b)) {
+		const key = a;
+		const items = b;
+		for (const [res, opts] of items) {
+			defineMetadata(res, key, opts);
+		}
+	} else {
+		const res = a;
+		const key = b;
+		const opts = c;
+		res.metadata = res.metadata || {};
+		set(res.metadata, key.key, opts);
+	}
 }
 
 export function getMetadata<T>(res: HasMetadata | undefined | null, key: MetadataKey<T>): T | undefined {
-  if (!res?.metadata) return undefined;
-  return get(res.metadata, key.key);
+	if (!res?.metadata) return undefined;
+	return get(res.metadata, key.key);
 }