@wener/common 1.0.1 → 1.0.3

package/src/cn/types.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 居民身份证
+ *
+ * @see https://en.wikipedia.org/wiki/Resident_Identity_Card
+ * @see https://en.wikipedia.org/wiki/Foreign_Permanent_Resident_ID_Card
+ */
+export interface ResidentIdentityCardInfo {
+  /**
+   * @title 姓名
+   */
+  name: string;
+  /**
+   * @title 性别
+   */
+  sex: 'Male' | 'Female';
+  /**
+   * @title 民族
+   * 例如 '汉'/'满'/'回'
+   */
+  ethnicity: string;
+  /**
+   * @title 出生日期
+   * @format date
+   */
+  birthDate: string;
+  /**
+   * @title 地址
+   *
+   * - 通常为 domicile/户籍地
+   */
+  address: string;
+  /**
+   * @title 身份证号
+   */
+  identityCardNumber: string;
+  /**
+   * @title 签发机关
+   */
+  issuer: string;
+  /**
+   * @title 有效期开始日期
+   * @format date
+   */
+  validStartDate: string;
+  /**
+   * @title 有效期结束日期
+   * @format date
+   * @description 如长期有效则为 空
+   */
+  validEndDate?: string;
+}

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/defineMetadata.ts

@@ -46,9 +46,22 @@ export function createMetadataKey<T = never>(a: any, b?: any): MetadataKey<T> {
   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 {

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';

package/src/parseSort.test.ts

@@ -35,6 +35,7 @@ test('parseSort', () => {
     ['a nulls first', [{ field: 'a', order: 'asc', nulls: 'first' }]],
     ['-a nulls first', [{ field: 'a', order: 'desc', nulls: 'first' }]],
     ['a.b', [{ field: 'a.b', order: 'asc' }]],
+    ['-a asc', [{ field: 'a', order: 'asc' }]], // asc 优先级高
   ]) {
     assert.deepEqual(parseSort(o as any), e as any, `parseOrder: ${JSON.stringify(o)}`);
   }

package/src/parseSort.ts

@@ -113,3 +113,21 @@ function _parse(v: string) {
     nulls,
   };
 }
+
+export function formatSort(s: SortRule[]): string[] {
+  return s
+    .map(({ field, order, nulls }) => {
+      if (field) {
+        let r = field;
+        if (order) {
+          r += ` ${order}`;
+        }
+        if (nulls) {
+          r += ` nulls ${nulls}`;
+        }
+        return r;
+      }
+      return '';
+    })
+    .filter(Boolean);
+}

package/src/search/AdvanceSearch.test.ts

@@ -0,0 +1,156 @@
+import { describe, expect, it } from 'vitest';
+import { AdvanceSearch } from './AdvanceSearch';
+
+describe('AdvanceSearch', () => {
+  it('should parse', () => {
+    for (const input of [
+      //
+      '-a',
+      'a',
+      'a b',
+      'a -b',
+      'a-b',
+      'a"b',
+      'a&b',
+      'NOT a',
+      'NOT -a',
+      'HELLO -WORLD',
+      '(a)',
+      '( a OR B )',
+      'A OR B',
+      'a:[1,2]',
+      'a:*..1',
+      'a:ok a:=1 a:>1 a:<1 a:>=1 a:<=1 a:!=1 a:1..2 a:*..1 a:1..* a:[1,2] a:(1,2) a:[1,2) a:(1,2]',
+      'NOT (A B) AND (a:ok AND size:>1)',
+      'NOT -a',
+      'NOT (NOT -a)',
+      'owner:@me owner:=@me owner:!=@me',
+      '@AI:"Where is my car"',
+      '/**/ a',
+      '/* Hint */ a',
+      '/* a */ a /* b */',
+    ]) {
+      let out = AdvanceSearch.parse(input);
+      let formated = AdvanceSearch.format(out);
+      expect(formated, `reformat`).toMatchSnapshot();
+      let optimized = AdvanceSearch.format(AdvanceSearch.optimize(out));
+      expect(optimized, `optimized`).toMatchSnapshot();
+      expect(out, `parsed`).toMatchSnapshot();
+      expect(AdvanceSearch.parse(formated), `reformat match original`).toMatchObject(out);
+    }
+  });
+  it('should parse as expected', () => {
+    type Case = [string | null | undefined, AdvanceSearch.Expr[]];
+
+    const cases: Case[] = [
+      [null, []],
+      [undefined, []],
+      ['', []],
+      // fast path
+      ['a', [{ type: 'keyword', value: 'a' }]],
+      ['a-b', [{ type: 'keyword', value: 'a-b' }]],
+      ['a"b', [{ type: 'keyword', value: 'a"b' }]],
+      [
+        'hello world',
+        [
+          { type: 'keyword', value: 'hello' },
+          { type: 'keyword', value: 'world' },
+        ],
+      ],
+      // advance
+      ['-a', [{ type: 'keyword', value: 'a', negative: true }]],
+      [
+        '/*Hi*/ hello -world',
+        [
+          { type: 'comment', value: 'Hi' },
+          { type: 'keyword', value: 'hello', negative: false },
+          {
+            type: 'keyword',
+            value: 'world',
+            negative: true,
+          },
+        ],
+      ],
+      ['"Hello"', [{ type: 'keyword', value: 'Hello', exact: true }]],
+      ['-"Hello"', [{ type: 'keyword', value: 'Hello', exact: true, negative: true }]],
+      ['is:ok', [{ type: 'compare', field: 'is', operator: 'match', value: { value: 'ok' } }]],
+      ['-is:ok', [{ type: 'compare', field: 'is', negative: true, operator: 'match', value: { value: 'ok' } }]],
+    ];
+
+    for (const [input, expected] of cases) {
+      let out = AdvanceSearch.parse(input);
+      expect(out).toMatchObject(expected);
+      expect(AdvanceSearch.parse(AdvanceSearch.format(out)), 'reformat should match').toMatchObject(expected);
+    }
+  });
+
+  it('should optimize simple', () => {
+    type Case = {
+      input: AdvanceSearch.Expr[];
+      expected: AdvanceSearch.Expr[];
+    };
+    const cases: Case[] = [
+      // rm empty comment
+      {
+        input: [
+          { type: 'comment', value: '' },
+          { type: 'keyword', value: 'a' },
+        ],
+        expected: [{ type: 'keyword', value: 'a' }],
+      },
+      // unwrap parentheses
+      {
+        input: [
+          { type: 'parentheses', value: [{ type: 'keyword', value: 'a' }] },
+          { type: 'keyword', value: 'b' },
+        ],
+        expected: [
+          { type: 'keyword', value: 'a' },
+          { type: 'keyword', value: 'b' },
+        ],
+      },
+      // not not
+      {
+        input: [{ type: 'not', value: { type: 'not', value: { type: 'keyword', value: 'a' } } }],
+        expected: [{ type: 'keyword', value: 'a', negative: false }],
+      },
+      // not to negative
+      {
+        input: [{ type: 'not', value: { type: 'keyword', value: 'a' } }],
+        expected: [{ type: 'keyword', value: 'a', negative: true }],
+      },
+    ];
+
+    for (let i = 0; i < cases.length; i++) {
+      const { input, expected } = cases[i];
+      let out = AdvanceSearch.optimize(input);
+      expect(out, `case #${i}`).toEqual(expected);
+    }
+  });
+
+  it('should optimize by formated', () => {
+    type Case = [string, string];
+
+    const cases: Case[] = [
+      ['( a )', 'a'],
+      ['NOT a', '-a'],
+      ['NOT -a', 'a'],
+      ['NOT is:ok', '-is:ok'],
+      ['NOT -is:ok', 'is:ok'],
+      ['NOT -is:=ok', 'is:=ok'],
+      ['NOT is:=ok', 'is:!=ok'],
+      ['NOT (NOT -a)', '-a'],
+    ];
+
+    for (const [input, expected] of cases) {
+      let out = AdvanceSearch.optimize(AdvanceSearch.parse(input));
+      expect(AdvanceSearch.format(out), `${input} -> ${expected}: ${JSON.stringify(out)}`).toEqual(expected);
+    }
+  });
+
+  it.fails('should parse parentheses', () => {
+    let out = AdvanceSearch.parse('(a)');
+    console.log(out);
+    expect(out).toEqual([{ type: 'parentheses', value: [{ type: 'keyword', value: 'a' }] }]);
+  });
+});

package/src/search/AdvanceSearch.ts

@@ -0,0 +1,14 @@
+import { formatAdvanceSearch } from './formatAdvanceSearch';
+import { optimizeAdvanceSearch } from './optimizeAdvanceSearch';
+import { parseAdvanceSearch } from './parseAdvanceSearch';
+import type * as types from './types';
+
+export namespace AdvanceSearch {
+  export type Exprs = types.Exprs;
+  export type Expr = types.Expr;
+  export type Value = types.Value;
+
+  export const parse = parseAdvanceSearch;
+  export const format = formatAdvanceSearch;
+  export const optimize = optimizeAdvanceSearch;
+}

package/src/search/Makefile

@@ -0,0 +1,2 @@
+gen:
+	pnpm dlx peggy@latest $(PWD)/parser.peggy --format es