lib0 1.0.0-rc.4 → 1.0.0-rc.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lib0",
-  "version": "1.0.0-rc.4",
+  "version": "1.0.0-rc.6",
   "description": "",
   "sideEffects": false,
   "type": "module",
@@ -288,7 +288,7 @@
     "trace-opt": "clear && node --trace-opt src/test.js",
     "lint": "tsc && standard",
     "gendocs": "node ./bin/gendocs.js",
-    "np": "np --test-script dist",
+    "release": "npm run dist && np --test-script dist",
     "version": "npm run clean && npm run dist && git add README.md",
     "postpublish": "npm run clean",
     "gentesthtml": "node ./src/bin/gentesthtml.js --script src/test.js > test.html"

package/src/delta/delta.js

@@ -346,7 +346,7 @@ export class DeleteOp extends list.ListNode {
   }
 
   get length () {
-    return 0
+    return this.delete
   }
 
   get fingerprint () {
@@ -1972,7 +1972,7 @@ export class $Delta extends s.Schema {
  * @param {Formats} [opts.formats]
  * @param {RecursiveChildren} [opts.recursiveChildren]
  * @return {[s.ReadSchemaUnwrapped<NodeNameSchema>,s.ReadSchemaUnwrapped<AttrsSchema>,s.ReadSchemaUnwrapped<ChildrenSchema>] extends [infer NodeName, infer Attrs, infer Children] ? s.Schema<Delta<PrettifyDeltaConf<(import('../ts.js').TypeIsAny<NodeName, {}, { name: NodeName }> &
- *   ({} extends Attrs ? {} : { attrs: Attrs }) &
+ *   ([keyof Attrs] extends [never] ? {} : { attrs: Attrs }) &
  *   ([Children] extends [never] ? {} : { children: Children }) &
  *   (HasText extends false ? {} : { text: HasText }) &
  *   (RecursiveChildren extends false ? {} : { recursiveChildren: RecursiveChildren })) extends infer DC extends DeltaConf ? DC : never>>> : never}
@@ -2325,7 +2325,7 @@ export const diff = (d1, d2) => {
     // split by alphanumerics and others
     const changeset3 = diffChangesetWithSeparator(changeset2, patience.smartSplitRegex)
     // split all
-    const changeset4 = diffChangesetWithSeparator(changeset3, /./g) // @todo this part should use myers diff
+    const changeset4 = diffChangesetWithSeparator(changeset3, /./g)
     applyChangesetToDelta(d, changeset4)
     if (formattingNeedsDiff) {
       const formattingDiff = create()

package/src/diff/patience.js

@@ -16,7 +16,7 @@ import * as array from '../array.js'
  *
  * @param {Array<string>} as
  * @param {Array<string>} bs
- * @return {Array<{ index: number, remove: Array<string>, insert: Array<string>}>} changeset @todo should use delta instead
+ * @return {Array<{ index: number, remove: Array<string>, insert: Array<string>}>} changeset
  */
 export const diff = (as, bs) => {
   const {
@@ -35,9 +35,11 @@ export const diff = (as, bs) => {
 export const diffSplitBy = (a, b, regexp) => {
   const isStringSeparator = typeof regexp === 'string'
   const separator = /** @type {string} */ (isStringSeparator ? regexp : '')
-  regexp = new RegExp(regexp, 'g')
-  const as = splitByRegexp(a, regexp, !isStringSeparator)
-  const bs = splitByRegexp(b, regexp, !isStringSeparator)
+  if (isStringSeparator) {
+    regexp = new RegExp(regexp, 'g')
+  }
+  const as = splitByRegexp(a, /** @type {RegExp} */ (regexp), !isStringSeparator)
+  const bs = splitByRegexp(b, /** @type {RegExp} */ (regexp), !isStringSeparator)
   const changes = diff(as, bs)
   let prevSplitIndex = 0
   let prevStringIndex = 0
@@ -54,11 +56,13 @@ export const diffSplitBy = (a, b, regexp) => {
 }
 
 /**
- * For internal use.
+ * Idea: match all "non-word" characters and keep them separate (spaces, comma, exclamation marks, ..).
+ * Anything that can be classivied as a word (emoji, char, number) will be bundled together. All other tokens are kept
+ * individually. "hello, world!!!!" => ['hello', ',', ' ', 'world', '!', '!']
  *
  * @experimental
  */
-export const smartSplitRegex = /[^\p{L}\p{N}]+/gu
+export const smartSplitRegex = /[^\p{L}\p{N}\p{Extended_Pictographic}\p{Emoji_Modifier}\u200D\uFE0F]/gu
 
 /**
  * Sensible default for diffing strings using patience (it's fast though).
@@ -76,7 +80,7 @@ export const diffAuto = (a, b) =>
       remove: dd.remove,
       index: dd.index + d.index
     }))
-  ).flat()
+  ).flat(1)
 
 /**
  * @param {Array<string>} as

package/src/schema.js

@@ -876,12 +876,75 @@ export class $Union extends Schema {
  */
 /* @__NO_SIDE_EFFECTS__ */
 export const $union = (...schemas) => schemas.findIndex($s => $$union.check($s)) >= 0
-  ? $union(...schemas.map($s => $($s)).map($s => $$union.check($s) ? $s.shape : [$s]).flat(1))
+  ? $union(...schemas.map($).map($s => $$union.check($s) ? $s.shape : [$s]).flat(1))
   : (schemas.length === 1
       ? schemas[0]
-      : new $Union(schemas))
+      : new $Union(schemas.map($)))
 export const $$union = /** @type {Schema<$Union<any>>} */ (/* @__PURE__ */$constructedBy($Union))
 
+/**
+ * @template {any} IN
+ * @typedef {[Extract<IN,Schema<any>>,Extract<IN,string|number|boolean|null>,Extract<IN,new (...args:any[])=>any>,Extract<IN,any[]>,Extract<Exclude<IN,Schema<any>|string|number|boolean|null|(new (...args:any[])=>any)|any[]>,object>] extends [infer Schemas, infer Primitives, infer Constructors, infer Arrs, infer Obj]
+ *   ? (
+ *     (Schemas extends Schema<infer S> ? S : never)
+ *     | Primitives
+ *     | (Constructors extends new (...args:any[])=>any ? InstanceType<Constructors> : never)
+ *     | (Arrs extends any[] ? { [K in keyof Arrs]: ReadSchemaUnwrapped<Arrs[K]> }[keyof Arrs & number] : never)
+ *     | (Obj extends object ? _ObjectDefToSchema<{[K in keyof Obj]:Schema<ReadSchemaUnwrapped<Obj[K]>>}> : never))
+ *   : never
+ * } ReadSchemaUnwrapped
+ */
+
+/**
+ * @template {any} IN
+ * @typedef {Schema<ReadSchemaUnwrapped<IN>>} ReadSchema
+ */
+
+/**
+ * @template IN
+ * @param {IN} o
+ * @return {Schema<import('./ts.js').TypeIsAny<IN,any,ReadSchemaUnwrapped<IN>>>}
+ */
+/* @__NO_SIDE_EFFECTS__ */
+export const $ = o => {
+  if ($$schema.check(o)) {
+    return /** @type {any} */ (o)
+  } else if ($objectAny.check(o)) {
+    /**
+     * @type {any}
+     */
+    const o2 = {}
+    for (const k in o) {
+      o2[k] = $(o[k])
+    }
+    return /** @type {any} */ ($object(o2))
+  } else if ($arrayAny.check(o)) {
+    return /** @type {any} */ ($union(...o.map($)))
+  } else if ($primitive.check(o)) {
+    return /** @type {any} */ ($literal(o))
+  } else if ($function.check(o)) {
+    return /** @type {any} */ ($constructedBy(/** @type {any} */ (o)))
+  }
+  /* c8 ignore next */
+  error.unexpectedCase()
+}
+
+/* c8 ignore start */
+/**
+ * Assert that a variable is of this specific type.
+ * The assertion check is only performed in non-production environments.
+ *
+ * @type {<T>(o:any,schema:Schema<T>) => asserts o is T}
+ */
+/* @__NO_SIDE_EFFECTS__ */
+export const assert = (o, schema) => {
+  const err = new ValidationError()
+  if (!schema.check(o, err)) {
+    throw error.create(`Expected value to be of type ${schema.constructor.name}.\n${err.toString()}`)
+  }
+}
+/* c8 ignore end */
+
 /* @__NO_SIDE_EFFECTS__ */
 const _t = () => true
 /**
@@ -969,69 +1032,6 @@ export const $json = /* @__PURE__ */(() => {
   return $json
 })()
 
-/**
- * @template {any} IN
- * @typedef {[Extract<IN,Schema<any>>,Extract<IN,string|number|boolean|null>,Extract<IN,new (...args:any[])=>any>,Extract<IN,any[]>,Extract<Exclude<IN,Schema<any>|string|number|boolean|null|(new (...args:any[])=>any)|any[]>,object>] extends [infer Schemas, infer Primitives, infer Constructors, infer Arrs, infer Obj]
- *   ? (
- *     (Schemas extends Schema<infer S> ? S : never)
- *     | Primitives
- *     | (Constructors extends new (...args:any[])=>any ? InstanceType<Constructors> : never)
- *     | (Arrs extends any[] ? { [K in keyof Arrs]: ReadSchemaUnwrapped<Arrs[K]> }[keyof Arrs & number] : never)
- *     | (Obj extends object ? _ObjectDefToSchema<{[K in keyof Obj]:Schema<ReadSchemaUnwrapped<Obj[K]>>}> : never))
- *   : never
- * } ReadSchemaUnwrapped
- */
-
-/**
- * @template {any} IN
- * @typedef {Schema<ReadSchemaUnwrapped<IN>>} ReadSchema
- */
-
-/**
- * @template IN
- * @param {IN} o
- * @return {Schema<import('./ts.js').TypeIsAny<IN,any,ReadSchemaUnwrapped<IN>>>}
- */
-/* @__NO_SIDE_EFFECTS__ */
-export const $ = o => {
-  if ($$schema.check(o)) {
-    return /** @type {any} */ (o)
-  } else if ($objectAny.check(o)) {
-    /**
-     * @type {any}
-     */
-    const o2 = {}
-    for (const k in o) {
-      o2[k] = $(o[k])
-    }
-    return /** @type {any} */ ($object(o2))
-  } else if ($arrayAny.check(o)) {
-    return /** @type {any} */ ($union(...o.map($)))
-  } else if ($primitive.check(o)) {
-    return /** @type {any} */ ($literal(o))
-  } else if ($function.check(o)) {
-    return /** @type {any} */ ($constructedBy(/** @type {any} */ (o)))
-  }
-  /* c8 ignore next */
-  error.unexpectedCase()
-}
-
-/* c8 ignore start */
-/**
- * Assert that a variable is of this specific type.
- * The assertion check is only performed in non-production environments.
- *
- * @type {<T>(o:any,schema:Schema<T>) => asserts o is T}
- */
-/* @__NO_SIDE_EFFECTS__ */
-export const assert = (o, schema) => {
-  const err = new ValidationError()
-  if (!schema.check(o, err)) {
-    throw error.create(`Expected value to be of type ${schema.constructor.name}.\n${err.toString()}`)
-  }
-}
-/* c8 ignore end */
-
 /**
  * @template In
  * @template Out

package/types/delta/delta.d.ts

@@ -746,7 +746,7 @@ export function $delta<NodeNameSchema extends s.Schema<string> | string | Array<
     recursiveChildren?: RecursiveChildren | undefined;
 }): [s.ReadSchemaUnwrapped<NodeNameSchema>, s.ReadSchemaUnwrapped<AttrsSchema>, s.ReadSchemaUnwrapped<ChildrenSchema>] extends [infer NodeName_1, infer Attrs_1, infer Children_1] ? s.Schema<Delta<PrettifyDeltaConf<(import("../ts.js").TypeIsAny<NodeName_1, {}, {
     name: NodeName_1;
-}> & ({} extends Attrs_1 ? {} : {
+}> & ([keyof Attrs_1] extends [never] ? {} : {
     attrs: Attrs_1;
 }) & ([Children_1] extends [never] ? {} : {
     children: Children_1;

package/types/diff/patience.d.ts

@@ -9,7 +9,9 @@ export function diffSplitBy(a: string, b: string, regexp: RegExp | string): {
     insert: string;
 }[];
 /**
- * For internal use.
+ * Idea: match all "non-word" characters and keep them separate (spaces, comma, exclamation marks, ..).
+ * Anything that can be classivied as a word (emoji, char, number) will be bundled together. All other tokens are kept
+ * individually. "hello, world!!!!" => ['hello', ',', ' ', 'world', '!', '!']
  *
  * @experimental
  */

package/types/schema.d.ts

@@ -442,6 +442,14 @@ export class $Union<S> extends Schema<S> {
 }
 export function $union<T extends Array<any>>(...schemas: T): CastToSchema<$Union<ReadSchemaUnwrapped<T>>>;
 export const $$union: Schema<$Union<any>>;
+export function $<IN>(o: IN): Schema<import("./ts.js").TypeIsAny<IN, any, ReadSchemaUnwrapped<IN>>>;
+/**
+ * Assert that a variable is of this specific type.
+ * The assertion check is only performed in non-production environments.
+ *
+ * @type {<T>(o:any,schema:Schema<T>) => asserts o is T}
+ */
+export const assert: <T>(o: any, schema: Schema<T>) => asserts o is T;
 /**
  * @type {Schema<any>}
  */
@@ -507,14 +515,6 @@ export const $primitive: Schema<Primitive>;
 export const $json: Schema<null | number | string | boolean | JSON[] | {
     [key: string]: JSON;
 }>;
-export function $<IN>(o: IN): Schema<import("./ts.js").TypeIsAny<IN, any, ReadSchemaUnwrapped<IN>>>;
-/**
- * Assert that a variable is of this specific type.
- * The assertion check is only performed in non-production environments.
- *
- * @type {<T>(o:any,schema:Schema<T>) => asserts o is T}
- */
-export const assert: <T>(o: any, schema: Schema<T>) => asserts o is T;
 /**
  * @todo move this to separate library
  * @template {any} [State=undefined]
@@ -574,12 +574,12 @@ export type $ObjectToType<S extends {
 }> = { [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? Key : never]?: S[Key] extends $Optional<Schema<infer Type>> ? Type : never; } & { [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? never : Key]: S[Key] extends Schema<infer Type> ? Type : never; };
 export type _ObjectDefToSchema<S> = import("./ts.js").Prettify<{ [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? Key : never]?: S[Key] extends $Optional<Schema<infer Type>> ? Type : never; } & { [Key in keyof S as S[Key] extends $Optional<Schema<any>> ? never : Key]: S[Key] extends Schema<infer Type> ? Type : never; }, 1>;
 export type _LArgsToLambdaDef<Args extends Schema<any>[]> = (...args: UnwrapArray<TuplePop<Args>>) => Unwrap<TupleLast<Args>>;
+export type ReadSchemaUnwrapped<IN extends unknown> = [Extract<IN, Schema<any>>, Extract<IN, string | number | boolean | null>, Extract<IN, new (...args: any[]) => any>, Extract<IN, any[]>, Extract<Exclude<IN, Schema<any> | string | number | boolean | null | (new (...args: any[]) => any) | any[]>, object>] extends [infer Schemas, infer Primitives, infer Constructors, infer Arrs, infer Obj] ? ((Schemas extends Schema<infer S> ? S : never) | Primitives | (Constructors extends new (...args: any[]) => any ? InstanceType<Constructors> : never) | (Arrs extends any[] ? { [K in keyof Arrs]: ReadSchemaUnwrapped<Arrs[K]>; }[keyof Arrs & number] : never) | (Obj extends object ? _ObjectDefToSchema<{ [K in keyof Obj]: Schema<ReadSchemaUnwrapped<Obj[K]>>; }> : never)) : never;
+export type ReadSchema<IN extends unknown> = Schema<ReadSchemaUnwrapped<IN>>;
 export type JSONArray = JSON[];
 export type JSON = Primitive | JSONArray | {
     [key: string]: JSON;
 };
-export type ReadSchemaUnwrapped<IN extends unknown> = [Extract<IN, Schema<any>>, Extract<IN, string | number | boolean | null>, Extract<IN, new (...args: any[]) => any>, Extract<IN, any[]>, Extract<Exclude<IN, Schema<any> | string | number | boolean | null | (new (...args: any[]) => any) | any[]>, object>] extends [infer Schemas, infer Primitives, infer Constructors, infer Arrs, infer Obj] ? ((Schemas extends Schema<infer S> ? S : never) | Primitives | (Constructors extends new (...args: any[]) => any ? InstanceType<Constructors> : never) | (Arrs extends any[] ? { [K in keyof Arrs]: ReadSchemaUnwrapped<Arrs[K]>; }[keyof Arrs & number] : never) | (Obj extends object ? _ObjectDefToSchema<{ [K in keyof Obj]: Schema<ReadSchemaUnwrapped<Obj[K]>>; }> : never)) : never;
-export type ReadSchema<IN extends unknown> = Schema<ReadSchemaUnwrapped<IN>>;
 export type Pattern<In, Out> = {
     if: Schema<In>;
     h: (o: In, state?: any) => Out;