@wener/common 1.0.2 → 1.0.4

package/src/meta/defineFileType.tsx

@@ -0,0 +1,68 @@
+type DefineFileTypeOptions = {
+	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>;
+};
+
+let _all: FileTypeDef[] = [];
+
+export function defineFileType({
+	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];
+	}
+
+	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;
+}

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,57 +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 { key } = opts;
-  opts.title ||= startCase(key);
-
-  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,
-    });
-  }
-
-  return k;
+	const opts: CreateMetadataKeyOptions = typeof a === 'string' ? { key: a, ...b } : a;
+
+	const { key } = opts;
+	opts.title ||= startCase(key);
+
+	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 });
+	}
+
+	return k;
 }
 
-export function defineMetadata<T>(res: HasMetadata, key: MetadataKey<T>, opts: T) {
-  res.metadata = res.metadata || {};
-  set(res.metadata, key.key, opts);
+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);
+	}
 }
 
 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);
 }

package/src/meta/index.ts

@@ -1,3 +1,5 @@
 export { createMetadataKey, defineMetadata, getMetadata } from './defineMetadata';
 
 export { defineInit, type InitDef, runInit } from './defineInit';
+
+export { defineFileType, getFileType, type FileTypeDef } from './defineFileType';