@tachybase/schema 0.23.41 → 0.23.48

package/lib/json-schema/shared.js

@@ -0,0 +1,232 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var shared_exports = {};
+__export(shared_exports, {
+  SchemaNestedMap: () => SchemaNestedMap,
+  SchemaNormalKeys: () => SchemaNormalKeys,
+  SchemaStateMap: () => SchemaStateMap,
+  SchemaValidatorKeys: () => SchemaValidatorKeys,
+  SchemaValidatorMap: () => SchemaValidatorMap,
+  createDataSource: () => createDataSource,
+  hasOwnProperty: () => hasOwnProperty,
+  isNoNeedCompileObject: () => isNoNeedCompileObject,
+  patchStateFormSchema: () => patchStateFormSchema,
+  traverse: () => traverse,
+  traverseSchema: () => traverseSchema
+});
+module.exports = __toCommonJS(shared_exports);
+var import_reactive = require("../reactive");
+var import_shared = require("../shared");
+var import_schema = require("./schema");
+const REVA_ACTIONS_KEY = Symbol.for("__REVA_ACTIONS");
+const SchemaNestedMap = {
+  parent: true,
+  root: true,
+  properties: true,
+  patternProperties: true,
+  additionalProperties: true,
+  items: true,
+  additionalItems: true,
+  "x-linkages": true,
+  "x-reactions": true
+};
+const SchemaStateMap = {
+  title: "title",
+  description: "description",
+  default: "initialValue",
+  enum: "dataSource",
+  readOnly: "readOnly",
+  writeOnly: "editable",
+  "x-content": "content",
+  "x-data": "data",
+  "x-value": "value",
+  "x-editable": "editable",
+  "x-disabled": "disabled",
+  "x-read-pretty": "readPretty",
+  "x-read-only": "readOnly",
+  "x-visible": "visible",
+  "x-hidden": "hidden",
+  "x-display": "display",
+  "x-pattern": "pattern",
+  "x-validator": "validator",
+  "x-decorator": "decoratorType",
+  "x-component": "componentType",
+  "x-decorator-props": "decoratorProps",
+  "x-component-props": "componentProps"
+};
+const SchemaValidatorMap = {
+  required: true,
+  format: true,
+  maxItems: true,
+  minItems: true,
+  maxLength: true,
+  minLength: true,
+  maximum: true,
+  minimum: true,
+  exclusiveMaximum: true,
+  exclusiveMinimum: true,
+  pattern: true,
+  const: true,
+  multipleOf: true,
+  maxProperties: true,
+  minProperties: true,
+  uniqueItems: true
+};
+const SchemaNormalKeys = Object.keys(SchemaStateMap);
+const SchemaValidatorKeys = Object.keys(SchemaValidatorMap);
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+const traverse = /* @__PURE__ */ __name((target, visitor) => {
+  const seenObjects = [];
+  const root = target;
+  const traverse2 = /* @__PURE__ */ __name((target2, path = []) => {
+    if ((0, import_shared.isPlainObj)(target2)) {
+      const seenIndex = seenObjects.indexOf(target2);
+      if (seenIndex > -1) {
+        return;
+      }
+      const addIndex = seenObjects.length;
+      seenObjects.push(target2);
+      if (isNoNeedCompileObject(target2) && root !== target2) {
+        visitor(target2, path);
+        return;
+      }
+      (0, import_shared.each)(target2, (value, key) => {
+        traverse2(value, path.concat(key));
+      });
+      seenObjects.splice(addIndex, 1);
+    } else {
+      visitor(target2, path);
+    }
+  }, "traverse");
+  traverse2(target);
+}, "traverse");
+const traverseSchema = /* @__PURE__ */ __name((schema, visitor) => {
+  var _a;
+  if (schema["x-validator"] !== void 0) {
+    visitor(schema["x-validator"], ["x-validator"], (_a = schema["x-compile-omitted"]) == null ? void 0 : _a.includes("x-validator"));
+  }
+  const seenObjects = [];
+  const root = schema;
+  const traverse2 = /* @__PURE__ */ __name((target, path = []) => {
+    var _a2;
+    if (path[0] === "x-compile-omitted" || path[0] === "x-validator" || path[0] === "version" || path[0] === "_isJSONSchemaObject")
+      return;
+    if (String(path[0]).indexOf("x-") === -1 && (0, import_shared.isFn)(target)) return;
+    if (SchemaNestedMap[path[0]]) return;
+    if (((_a2 = schema["x-compile-omitted"]) == null ? void 0 : _a2.indexOf(path[0])) > -1) {
+      visitor(target, path, true);
+      return;
+    }
+    if ((0, import_shared.isPlainObj)(target)) {
+      if (path[0] === "default" || path[0] === "x-value") {
+        visitor(target, path);
+        return;
+      }
+      const seenIndex = seenObjects.indexOf(target);
+      if (seenIndex > -1) {
+        return;
+      }
+      const addIndex = seenObjects.length;
+      seenObjects.push(target);
+      if (isNoNeedCompileObject(target) && root !== target) {
+        visitor(target, path);
+        return;
+      }
+      (0, import_shared.each)(target, (value, key) => {
+        traverse2(value, path.concat(key));
+      });
+      seenObjects.splice(addIndex, 1);
+    } else {
+      visitor(target, path);
+    }
+  }, "traverse");
+  traverse2(schema);
+}, "traverseSchema");
+const isNoNeedCompileObject = /* @__PURE__ */ __name((source) => {
+  if ("$$typeof" in source && "_owner" in source) {
+    return true;
+  }
+  if (source["_isAMomentObject"]) {
+    return true;
+  }
+  if (import_schema.Schema.isSchemaInstance(source)) {
+    return true;
+  }
+  if (source[REVA_ACTIONS_KEY]) {
+    return true;
+  }
+  if ((0, import_shared.isFn)(source["toJS"])) {
+    return true;
+  }
+  if ((0, import_shared.isFn)(source["toJSON"])) {
+    return true;
+  }
+  if ((0, import_reactive.isObservable)(source)) {
+    return true;
+  }
+  return false;
+}, "isNoNeedCompileObject");
+const createDataSource = /* @__PURE__ */ __name((source) => {
+  return (0, import_shared.toArr)(source).map((item) => {
+    if (typeof item === "object") {
+      return item;
+    } else {
+      return {
+        label: item,
+        value: item
+      };
+    }
+  });
+}, "createDataSource");
+const patchStateFormSchema = /* @__PURE__ */ __name((targetState, pattern, compiled) => {
+  (0, import_reactive.untracked)(() => {
+    var _a;
+    const path = import_shared.FormPath.parse(pattern);
+    const segments = path.segments;
+    const key = segments[0];
+    const isEnum = key === "enum" && (0, import_shared.isArr)(compiled);
+    const schemaMapKey = SchemaStateMap[key];
+    if (schemaMapKey) {
+      import_shared.FormPath.setIn(
+        targetState,
+        [schemaMapKey].concat(segments.slice(1)),
+        isEnum ? createDataSource(compiled) : compiled
+      );
+    } else {
+      const isValidatorKey = SchemaValidatorMap[key];
+      if (isValidatorKey) {
+        (_a = targetState["setValidatorRule"]) == null ? void 0 : _a.call(targetState, key, compiled);
+      }
+    }
+  });
+}, "patchStateFormSchema");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SchemaNestedMap,
+  SchemaNormalKeys,
+  SchemaStateMap,
+  SchemaValidatorKeys,
+  SchemaValidatorMap,
+  createDataSource,
+  hasOwnProperty,
+  isNoNeedCompileObject,
+  patchStateFormSchema,
+  traverse,
+  traverseSchema
+});

package/lib/json-schema/transformer.d.ts

@@ -0,0 +1,4 @@
+import { IFieldFactoryProps } from '../core';
+import { Schema } from './schema';
+import { ISchemaTransformerOptions } from './types';
+export declare const transformFieldProps: (schema: Schema, options: ISchemaTransformerOptions) => IFieldFactoryProps<any, any>;

package/lib/json-schema/transformer.js

@@ -0,0 +1,238 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var transformer_exports = {};
+__export(transformer_exports, {
+  transformFieldProps: () => transformFieldProps
+});
+module.exports = __toCommonJS(transformer_exports);
+var import_core = require("../core");
+var import_reactive = require("../reactive");
+var import_shared = require("../shared");
+var import_compiler = require("./compiler");
+const FieldEffects = {
+  onFieldInit: import_core.onFieldInit,
+  onFieldMount: import_core.onFieldMount,
+  onFieldUnmount: import_core.onFieldUnmount,
+  onFieldValueChange: import_core.onFieldValueChange,
+  onFieldInputValueChange: import_core.onFieldInputValueChange,
+  onFieldInitialValueChange: import_core.onFieldInitialValueChange,
+  onFieldValidateStart: import_core.onFieldValidateStart,
+  onFieldValidateEnd: import_core.onFieldValidateEnd,
+  onFieldValidateFailed: import_core.onFieldValidateFailed,
+  onFieldValidateSuccess: import_core.onFieldValidateSuccess
+};
+const DefaultFieldEffects = ["onFieldInit", "onFieldValueChange"];
+const getDependencyValue = /* @__PURE__ */ __name((field, pattern, property) => {
+  const [target, path] = String(pattern).split(/\s*#\s*/);
+  return field.query(target).getIn(path || property || "value");
+}, "getDependencyValue");
+const getDependencies = /* @__PURE__ */ __name((field, dependencies) => {
+  if ((0, import_shared.isArr)(dependencies)) {
+    const results = [];
+    dependencies.forEach((pattern) => {
+      if ((0, import_shared.isStr)(pattern)) {
+        results.push(getDependencyValue(field, pattern));
+      } else if ((0, import_shared.isPlainObj)(pattern)) {
+        if (pattern.name && pattern.source) {
+          results[pattern.name] = getDependencyValue(field, pattern.source, pattern.property);
+        }
+      }
+    });
+    return results;
+  } else if ((0, import_shared.isPlainObj)(dependencies)) {
+    return (0, import_shared.reduce)(
+      dependencies,
+      (buf, pattern, key) => {
+        buf[key] = getDependencyValue(field, pattern);
+        return buf;
+      },
+      {}
+    );
+  }
+  return [];
+}, "getDependencies");
+const setSchemaFieldState = /* @__PURE__ */ __name((options, demand = false) => {
+  const { request, target, runner, field, scope } = options || {};
+  if (!request) return;
+  if (target) {
+    if (request.state) {
+      field.form.setFieldState(
+        target,
+        (state) => (0, import_compiler.patchCompile)(
+          state,
+          request.state,
+          (0, import_shared.lazyMerge)(scope, {
+            $target: state
+          })
+        )
+      );
+    }
+    if (request.schema) {
+      field.form.setFieldState(
+        target,
+        (state) => (0, import_compiler.patchSchemaCompile)(
+          state,
+          request.schema,
+          (0, import_shared.lazyMerge)(scope, {
+            $target: state
+          }),
+          demand
+        )
+      );
+    }
+    if ((0, import_shared.isStr)(runner) && runner) {
+      field.form.setFieldState(target, (state) => {
+        (0, import_compiler.shallowCompile)(
+          `{{function(){${runner}}}}`,
+          (0, import_shared.lazyMerge)(scope, {
+            $target: state
+          })
+        )();
+      });
+    }
+  } else {
+    if (request.state) {
+      field.setState((state) => (0, import_compiler.patchCompile)(state, request.state, scope));
+    }
+    if (request.schema) {
+      field.setState((state) => (0, import_compiler.patchSchemaCompile)(state, request.schema, scope, demand));
+    }
+    if ((0, import_shared.isStr)(runner) && runner) {
+      (0, import_compiler.shallowCompile)(`{{function(){${runner}}}}`, scope)();
+    }
+  }
+}, "setSchemaFieldState");
+const getBaseScope = /* @__PURE__ */ __name((field, options = {}) => {
+  const $observable = /* @__PURE__ */ __name((target, deps) => import_reactive.autorun.memo(() => (0, import_reactive.observable)(target), deps), "$observable");
+  const $props = /* @__PURE__ */ __name((props) => field.setComponentProps(props), "$props");
+  const $effect = import_reactive.autorun.effect;
+  const $memo = import_reactive.autorun.memo;
+  const $self = field;
+  const $form = field.form;
+  const $values = field.form.values;
+  return (0, import_shared.lazyMerge)(
+    {
+      get $lookup() {
+        var _a;
+        return ((_a = options == null ? void 0 : options.scope) == null ? void 0 : _a.$record) ?? $values;
+      },
+      get $records() {
+        return field.records;
+      },
+      get $record() {
+        const record = field.record;
+        if (typeof record === "object") {
+          return (0, import_shared.lazyMerge)(record, {
+            get $lookup() {
+              var _a;
+              return ((_a = options == null ? void 0 : options.scope) == null ? void 0 : _a.$record) ?? $values;
+            },
+            get $index() {
+              return field.index;
+            }
+          });
+        }
+        return record;
+      },
+      get $index() {
+        return field.index;
+      }
+    },
+    options.scope,
+    {
+      $form,
+      $self,
+      $observable,
+      $effect,
+      $memo,
+      $props,
+      $values
+    }
+  );
+}, "getBaseScope");
+const getBaseReactions = /* @__PURE__ */ __name((schema, options) => (field) => {
+  setSchemaFieldState(
+    {
+      field,
+      request: { schema },
+      scope: getBaseScope(field, options)
+    },
+    true
+  );
+}, "getBaseReactions");
+const getUserReactions = /* @__PURE__ */ __name((schema, options) => {
+  const reactions = (0, import_shared.toArr)(schema["x-reactions"]);
+  return reactions.map((unCompiled) => {
+    return (field) => {
+      const baseScope = getBaseScope(field, options);
+      const reaction = (0, import_compiler.shallowCompile)(unCompiled, baseScope);
+      if (!reaction) return;
+      if ((0, import_shared.isFn)(reaction)) {
+        return reaction(field, baseScope);
+      }
+      const { when, fulfill, otherwise, target, effects } = reaction;
+      const run = /* @__PURE__ */ __name(() => {
+        const $deps = getDependencies(field, reaction.dependencies);
+        const $dependencies = $deps;
+        const scope = (0, import_shared.lazyMerge)(baseScope, {
+          $target: null,
+          $deps,
+          $dependencies
+        });
+        const compiledWhen = (0, import_compiler.shallowCompile)(when, scope);
+        const condition = when ? compiledWhen : true;
+        const request = condition ? fulfill : otherwise;
+        const runner = request == null ? void 0 : request.run;
+        setSchemaFieldState({
+          field,
+          target,
+          request,
+          runner,
+          scope
+        });
+      }, "run");
+      if (target) {
+        reaction.effects = (effects == null ? void 0 : effects.length) ? effects : DefaultFieldEffects;
+      }
+      if (reaction.effects) {
+        import_reactive.autorun.memo(() => {
+          (0, import_reactive.untracked)(() => {
+            (0, import_shared.each)(reaction.effects, (type) => {
+              if (FieldEffects[type]) {
+                FieldEffects[type](field.address, run);
+              }
+            });
+          });
+        }, []);
+      } else {
+        run();
+      }
+    };
+  });
+}, "getUserReactions");
+const transformFieldProps = /* @__PURE__ */ __name((schema, options) => {
+  return {
+    name: schema.name,
+    reactions: [getBaseReactions(schema, options)].concat(getUserReactions(schema, options))
+  };
+}, "transformFieldProps");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  transformFieldProps
+});

package/lib/json-schema/types.d.ts

@@ -0,0 +1,119 @@
+import { FormPathPattern, GeneralField, IGeneralFieldState } from '../core';
+export type SchemaEnum<Message> = Array<string | number | boolean | {
+    label?: Message;
+    value?: any;
+    [key: string]: any;
+} | {
+    key?: any;
+    title?: Message;
+    [key: string]: any;
+}>;
+export type SchemaTypes = 'string' | 'object' | 'array' | 'number' | 'boolean' | 'void' | 'date' | 'datetime' | (string & {});
+export type SchemaProperties<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message> = Record<string, ISchema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>>;
+export type SchemaPatch = (schema: ISchema) => ISchema;
+export type SchemaKey = string | number;
+export type SchemaEffectTypes = 'onFieldInit' | 'onFieldMount' | 'onFieldUnmount' | 'onFieldValueChange' | 'onFieldInputValueChange' | 'onFieldInitialValueChange' | 'onFieldValidateStart' | 'onFieldValidateEnd' | 'onFieldValidateFailed' | 'onFieldValidateSuccess';
+export type SchemaReaction<Field = any> = {
+    dependencies?: Array<string | {
+        name?: string;
+        type?: string;
+        source?: string;
+        property?: string;
+    }> | Record<string, string>;
+    when?: string | boolean;
+    target?: string;
+    effects?: (SchemaEffectTypes | (string & {}))[];
+    fulfill?: {
+        state?: Stringify<IGeneralFieldState>;
+        schema?: ISchema;
+        run?: string;
+    };
+    otherwise?: {
+        state?: Stringify<IGeneralFieldState>;
+        schema?: ISchema;
+        run?: string;
+    };
+    [key: string]: any;
+} | ((field: Field, scope: IScopeContext) => void);
+export type SchemaReactions<Field = any> = SchemaReaction<Field> | SchemaReaction<Field>[];
+export type SchemaItems<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message> = ISchema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message> | ISchema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>[];
+export type SchemaComponents = Record<string, any>;
+export interface ISchemaFieldUpdateRequest {
+    state?: Stringify<IGeneralFieldState>;
+    schema?: ISchema;
+    run?: string;
+}
+export interface IScopeContext {
+    [key: string]: any;
+}
+export interface IFieldStateSetterOptions {
+    field: GeneralField;
+    target?: FormPathPattern;
+    request: ISchemaFieldUpdateRequest;
+    runner?: string;
+    scope?: IScopeContext;
+}
+export interface ISchemaTransformerOptions {
+    scope?: IScopeContext;
+}
+export type Stringify<P extends {
+    [key: string]: any;
+}> = {
+    [key in keyof P]?: P[key] | (string & {});
+};
+export type ISchema<Decorator = any, Component = any, DecoratorProps = any, ComponentProps = any, Pattern = any, Display = any, Validator = any, Message = any, ReactionField = any> = Stringify<{
+    version?: string;
+    name?: SchemaKey;
+    title?: Message;
+    description?: Message;
+    default?: any;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+    type?: SchemaTypes;
+    enum?: SchemaEnum<Message>;
+    const?: any;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: number;
+    minimum?: number;
+    exclusiveMinimum?: number;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string | RegExp;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    required?: string[] | boolean | string;
+    format?: string;
+    $ref?: string;
+    $namespace?: string;
+    /** nested json schema spec **/
+    definitions?: SchemaProperties<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>;
+    properties?: SchemaProperties<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>;
+    items?: SchemaItems<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>;
+    additionalItems?: ISchema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>;
+    patternProperties?: SchemaProperties<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>;
+    additionalProperties?: ISchema<Decorator, Component, DecoratorProps, ComponentProps, Pattern, Display, Validator, Message>;
+    ['x-value']?: any;
+    ['x-index']?: number;
+    ['x-pattern']?: Pattern;
+    ['x-display']?: Display;
+    ['x-validator']?: Validator;
+    ['x-decorator']?: Decorator | (string & {}) | ((...args: any[]) => any);
+    ['x-decorator-props']?: DecoratorProps;
+    ['x-component']?: Component | (string & {}) | ((...args: any[]) => any);
+    ['x-component-props']?: ComponentProps;
+    ['x-reactions']?: SchemaReactions<ReactionField>;
+    ['x-content']?: any;
+    ['x-data']?: any;
+    ['x-visible']?: boolean;
+    ['x-hidden']?: boolean;
+    ['x-disabled']?: boolean;
+    ['x-editable']?: boolean;
+    ['x-read-only']?: boolean;
+    ['x-read-pretty']?: boolean;
+    ['x-compile-omitted']?: string[];
+    [key: `x-${string | number}` | symbol]: any;
+}>;

package/lib/json-schema/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/lib/path/contexts.d.ts

@@ -0,0 +1,10 @@
+export type Context = {
+    flag: string;
+    [key: string]: any;
+};
+export declare const bracketContext: Context;
+export declare const bracketArrayContext: Context;
+export declare const bracketDContext: Context;
+export declare const parenContext: Context;
+export declare const braceContext: Context;
+export declare const destructorContext: Context;

package/lib/path/contexts.js

@@ -0,0 +1,49 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var contexts_exports = {};
+__export(contexts_exports, {
+  braceContext: () => braceContext,
+  bracketArrayContext: () => bracketArrayContext,
+  bracketContext: () => bracketContext,
+  bracketDContext: () => bracketDContext,
+  destructorContext: () => destructorContext,
+  parenContext: () => parenContext
+});
+module.exports = __toCommonJS(contexts_exports);
+const ContextType = /* @__PURE__ */ __name((flag, props) => {
+  return {
+    flag,
+    ...props
+  };
+}, "ContextType");
+const bracketContext = ContextType("[]");
+const bracketArrayContext = ContextType("[\\d]");
+const bracketDContext = ContextType("[[]]");
+const parenContext = ContextType("()");
+const braceContext = ContextType("{}");
+const destructorContext = ContextType("{x}");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  braceContext,
+  bracketArrayContext,
+  bracketContext,
+  bracketDContext,
+  destructorContext,
+  parenContext
+});

package/lib/path/destructor.d.ts

@@ -0,0 +1,15 @@
+import { DestructorRules, Node, Segments } from './types';
+type Mutators = {
+    getIn: (segments: Segments, source: any) => any;
+    setIn: (segments: Segments, source: any, value: any) => void;
+    deleteIn?: (segments: Segments, source: any) => any;
+    existIn?: (segments: Segments, source: any, start: number) => boolean;
+};
+export declare const getDestructor: (source: string) => any;
+export declare const setDestructor: (source: string, rules: DestructorRules) => void;
+export declare const parseDestructorRules: (node: Node) => DestructorRules;
+export declare const setInByDestructor: (source: any, rules: DestructorRules, value: any, mutators: Mutators) => void;
+export declare const getInByDestructor: (source: any, rules: DestructorRules, mutators: Mutators) => {};
+export declare const deleteInByDestructor: (source: any, rules: DestructorRules, mutators: Mutators) => void;
+export declare const existInByDestructor: (source: any, rules: DestructorRules, start: number, mutators: Mutators) => boolean;
+export {};