easybill-ui 1.4.1 → 1.4.2

package/dist/components/CurdForm/src/components/schema-form-tree-select.vue.d.ts

@@ -0,0 +1,58 @@
+declare const _default: import('vue').DefineComponent<{
+    modelValue: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    formItem: {
+        type: import('vue').PropType<import('../../../../index.ts').FormItem>;
+        default: () => {};
+    };
+    formModel: {
+        type: import('vue').PropType<import('../../../../index.ts').Fields>;
+        default: () => {};
+    };
+    props: {
+        type: import('vue').PropType<import('../../../../index.ts').FormItemPropObject>;
+        default: () => {};
+    };
+    eventObject: {
+        type: import('vue').PropType<import('../../../../index.ts').EventObject>;
+        default: () => {};
+    };
+}, {
+    model: import('vue').WritableComputedRef<string | number | boolean>;
+    empty: string | import('vue').VNode<import('vue').RendererNode, import('vue').RendererElement, {
+        [key: string]: any;
+    }>;
+    t: import('../../../../index.ts').Translator;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: (BooleanConstructor | StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    formItem: {
+        type: import('vue').PropType<import('../../../../index.ts').FormItem>;
+        default: () => {};
+    };
+    formModel: {
+        type: import('vue').PropType<import('../../../../index.ts').Fields>;
+        default: () => {};
+    };
+    props: {
+        type: import('vue').PropType<import('../../../../index.ts').FormItemPropObject>;
+        default: () => {};
+    };
+    eventObject: {
+        type: import('vue').PropType<import('../../../../index.ts').EventObject>;
+        default: () => {};
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}, {
+    props: import('../../../../index.ts').FormItemPropObject;
+    modelValue: string | number | boolean;
+    formItem: import('../../../../index.ts').FormItem;
+    formModel: import('../../../../index.ts').Fields;
+    eventObject: import('../../../../index.ts').EventObject;
+}, {}>;
+export default _default;

package/dist/components/CurdForm/src/components/schema-form-tree-select.vue.js

@@ -0,0 +1,55 @@
+import k from "./schema-form-tree-select.vue2.js";
+import { resolveComponent as t, createElementBlock as n, openBlock as o, createCommentVNode as l, createBlock as d, createVNode as r, createTextVNode as i, withCtx as f, toDisplayString as c, mergeProps as I, toHandlers as V, resolveDynamicComponent as v, Fragment as _, createElementVNode as C } from "vue";
+import N from "../../../../_virtual/_plugin-vue_export-helper.js";
+const T = { class: "schema-tree-select" }, $ = {
+  key: 0,
+  class: "loading",
+  style: { color: "#999", "font-size": "12px" }
+}, w = {
+  key: 2,
+  class: "empty"
+};
+function B(e, m, D, S, E, F) {
+  var a, p;
+  const u = t("Loading"), s = t("el-icon"), g = t("el-tree-select"), y = t("Warning");
+  return o(), n("div", T, [
+    e.formItem.loading ? (o(), n("div", $, [
+      r(s, { class: "is-loading" }, {
+        default: f(() => [
+          r(u)
+        ]),
+        _: 1
+      }),
+      i(" " + c(e.t("el.form.loading")), 1)
+    ])) : l("", !0),
+    !e.formItem.loading && e.formItem.options && e.formItem.options.length ? (o(), d(g, I({
+      key: 1,
+      modelValue: e.model,
+      "onUpdate:modelValue": m[0] || (m[0] = (h) => e.model = h),
+      class: [(a = e.props) == null ? void 0 : a.showType],
+      style: { width: "100%" },
+      data: e.formItem.options
+    }, e.props, V(e.eventObject)), null, 16, ["modelValue", "class", "data"])) : l("", !0),
+    !e.formItem.loading && !((p = e.formItem.options) != null && p.length) ? (o(), n("div", w, [
+      e.empty ? (o(), d(v(e.empty), {
+        key: 0,
+        "form-model": e.formModel,
+        "form-item": e.formItem,
+        props: e.props
+      }, null, 8, ["form-model", "form-item", "props"])) : (o(), n(_, { key: 1 }, [
+        r(s, null, {
+          default: f(() => [
+            r(y)
+          ]),
+          _: 1
+        }),
+        i(),
+        C("span", null, c(e.props.noDataText || e.t("el.form.nodata")), 1)
+      ], 64))
+    ])) : l("", !0)
+  ]);
+}
+const j = /* @__PURE__ */ N(k, [["render", B]]);
+export {
+  j as default
+};

package/dist/components/CurdForm/src/components/schema-form-tree-select.vue2.js

@@ -0,0 +1,31 @@
+import { Warning as a, Loading as p } from "@element-plus/icons-vue";
+import { useLocale as n } from "../../../../utils/hooks/useLocal.js";
+import { defineComponent as l, computed as u, toRaw as d } from "vue";
+import { FormItemProps as s } from "../types.js";
+const V = l({
+  name: "SchemaFormTreeSelect",
+  components: { Loading: p, Warning: a },
+  props: {
+    ...s,
+    modelValue: {
+      type: [String, Number, Boolean],
+      default: ""
+    }
+    // 表单项值
+  },
+  emits: ["update:modelValue"],
+  setup(e, { emit: o }) {
+    const t = u({
+      get: () => e.modelValue,
+      set: (r) => o("update:modelValue", r)
+    }), { t: m } = n();
+    return {
+      model: t,
+      empty: d(e.props.empty) || "",
+      t: m
+    };
+  }
+});
+export {
+  V as default
+};

package/dist/components/CurdForm/src/components/schema-form-value.vue.d.ts

@@ -0,0 +1,54 @@
+declare const _default: import('vue').DefineComponent<{
+    formItem: {
+        type: import('vue').PropType<import('../types').FormItem>;
+        default: () => {};
+    };
+    formModel: {
+        type: import('vue').PropType<import('../types').Fields>;
+        default: () => {};
+    };
+    props: {
+        type: import('vue').PropType<import('../types').FormItemPropObject>;
+        default: () => {};
+    };
+    eventObject: {
+        type: import('vue').PropType<import('../types').EventObject>;
+        default: () => {};
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {
+    model: import('vue').WritableComputedRef<string>;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    formItem: {
+        type: import('vue').PropType<import('../types').FormItem>;
+        default: () => {};
+    };
+    formModel: {
+        type: import('vue').PropType<import('../types').Fields>;
+        default: () => {};
+    };
+    props: {
+        type: import('vue').PropType<import('../types').FormItemPropObject>;
+        default: () => {};
+    };
+    eventObject: {
+        type: import('vue').PropType<import('../types').EventObject>;
+        default: () => {};
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}, {
+    props: import('../types').FormItemPropObject;
+    modelValue: string;
+    formItem: import('../types').FormItem;
+    formModel: import('../types').Fields;
+    eventObject: import('../types').EventObject;
+}, {}>;
+export default _default;

package/dist/components/CurdForm/src/components/schema-form-value.vue.js

@@ -0,0 +1,11 @@
+import o from "./schema-form-value.vue2.js";
+import { createElementBlock as r, openBlock as n, mergeProps as t } from "vue";
+import p from "../../../../_virtual/_plugin-vue_export-helper.js";
+const m = ["innerHTML"];
+function s(e, c, i, a, f, l) {
+  return n(), r("div", t(e.props, { innerHTML: e.model }), null, 16, m);
+}
+const $ = /* @__PURE__ */ p(o, [["render", s]]);
+export {
+  $ as default
+};

package/dist/components/CurdForm/src/components/schema-form-value.vue2.js

@@ -0,0 +1,21 @@
+import { defineComponent as t, computed as p } from "vue";
+import { FormItemProps as a } from "../types.js";
+const n = t({
+  name: "SchemaFormValue",
+  components: {},
+  props: {
+    ...a
+  },
+  emits: ["update:modelValue"],
+  setup(e, { emit: o }) {
+    return {
+      model: p({
+        get: () => e.modelValue,
+        set: (m) => o("update:modelValue", m)
+      })
+    };
+  }
+});
+export {
+  n as default
+};

package/dist/components/CurdForm/src/directive/index.d.ts

@@ -0,0 +1,12 @@
+declare const directives: {
+    trim: {
+        mounted(el: El): void;
+        unmounted(el: El): void;
+    };
+};
+interface El extends HTMLElement {
+    inputEle: HTMLElement;
+    _blurHandler: (event: FocusEvent) => void;
+    _keyHandler: (event: KeyboardEvent) => void;
+}
+export { directives };

package/dist/components/CurdForm/src/directive/index.js

@@ -0,0 +1,32 @@
+function c(e) {
+  let t;
+  return e.tagName !== "INPUT" ? t = e.querySelector("input") : t = e, t;
+}
+function o(e, t) {
+  const r = document.createEvent("HTMLEvents");
+  r.initEvent(t, !0, !0), e.dispatchEvent(r);
+}
+const s = {
+  trim: {
+    mounted(e) {
+      const t = c(e), r = function(i) {
+        if (!i.target) return;
+        const n = i.target, u = n.value.trim();
+        n.value !== u && (n.value = u, o(t, "input"));
+      }, a = function(i) {
+        if (i.key === "Enter") {
+          const n = i.target, u = n.value.trim();
+          n.value !== u && (n.value = u, o(t, "input"));
+        }
+      };
+      e.inputEle = t, e._blurHandler = r, e._keyHandler = a, t && t.addEventListener("blur", r), t && t.addEventListener("keydown", a);
+    },
+    unmounted(e) {
+      const { inputEle: t } = e;
+      t && t.removeEventListener("blur", e._blurHandler), t && t.removeEventListener("keydown", e._keyHandler);
+    }
+  }
+};
+export {
+  s as directives
+};

package/dist/components/CurdForm/src/hooks/index.d.ts

@@ -0,0 +1,4 @@
+import { FormContext } from '../types';
+export declare function useForm(): {
+    formContext: FormContext;
+};

package/dist/components/CurdForm/src/hooks/index.js

@@ -0,0 +1,7 @@
+import { inject as o } from "vue";
+function n() {
+  return { formContext: o("curdFormContext", {}) };
+}
+export {
+  n as useForm
+};

package/dist/components/CurdForm/src/types.d.ts

@@ -0,0 +1,136 @@
+import { ElForm, FormItemRule, FormRules } from 'element-plus';
+import { Arrayable } from 'element-plus/es/utils';
+import { defineComponent, PropType, VNode } from 'vue';
+import { OptionItem } from '../../ConstantStatus';
+export interface FormSchema {
+    formItem: FormItem[];
+    rules?: FormRules | ((formModel: Fields, context: FormContext) => FormRules);
+    getRules?: (formModel: Fields, context: FormContext) => FormRules;
+    labelPosition?: "left" | "right" | "top" | string;
+    gutter?: number;
+    labelWidth?: number | string;
+    inline?: boolean;
+    inlineMessage?: boolean;
+    statusIcon?: boolean;
+    showMessage?: boolean;
+    size?: "default" | "small" | "large" | string;
+    disabled?: boolean;
+    validateOnRuleChange?: boolean;
+    hideRequiredAsterisk?: boolean;
+    scrollToError?: boolean;
+}
+export interface FormItem {
+    prop: string;
+    label?: string;
+    type?: FormItemTypeEmun | ReturnType<typeof defineComponent>;
+    value?: unknown;
+    eventObject?: EventObject;
+    slots?: Record<string, () => VNode[] | string | null>;
+    options?: Array<CurdFormOptionItem>;
+    asyncOptions?: (modelRef: Fields, formItem: FormItem, context: FormContext, config?: unknown) => Promise<Array<CurdFormOptionItem>>;
+    loading?: boolean;
+    hidden?: boolean | ((model: Fields) => boolean);
+    rules?: Arrayable<FormItemRule>;
+    props?: FormItemPropObject | ((formModel: Fields, formItem: FormItem) => FormItemPropObject);
+    formItemProps?: FormItemPropObject | ((formModel: Fields, formItem: FormItem) => FormItemPropObject);
+    labelWidth?: string | number;
+    labelPosition?: "left" | "right" | "top" | string;
+    span?: number;
+    disabled?: boolean;
+    tooltip?: string | ((formModel: Fields, formItem: FormItem) => Partial<TooltipProps> | string) | Partial<TooltipProps>;
+    autoload?: boolean;
+    prefix?: string | unknown;
+    suffix?: string | unknown;
+    empty?: string | unknown;
+    sortIndex?: number;
+}
+export type FormItemTypeEmun = "input" | "select" | "radio" | "checkbox" | "input-number" | "switch" | "file" | "date-picker" | "time-picker" | "color-picker" | "value" | "tree-select" | "autocomplete" | "choose";
+export interface FormItemPropObject extends Fields {
+    slots?: Record<string, (props?: FormItemPropObject) => VNode | VNode[] | string | null>;
+    all?: boolean | OptionItem;
+    empty?: string | VNode;
+    noDataText?: string;
+    style?: Record<string, string> | string;
+}
+export interface TooltipProps extends Record<string, unknown> {
+    effect?: "dark" | "light" | string;
+    content?: string;
+    rawContent?: boolean;
+    placement?: string;
+    disabled?: boolean;
+    offset?: number;
+    transition?: string;
+    popperOptions?: unknown;
+    showAfter?: number;
+    showArrow?: boolean;
+    hideAfter?: number;
+    autoClose?: number;
+    popperClass?: string;
+    enterable?: boolean;
+    teleported?: boolean;
+    trigger?: string | string[];
+}
+export interface FormContext {
+    loadOptions: (prop: string, config?: unknown) => void | Promise<CurdFormOptionItem[]> | CurdFormOptionItem[];
+    setOptions: (prop: string, options: CurdFormOptionItem[], config?: unknown) => void | Promise<void>;
+    change: (formModel: Fields, formItem: FormItem) => void;
+    formModel: Fields;
+    formSchema: FormSchema;
+    formRef: InstanceType<typeof ElForm> | undefined;
+    components: Record<string, unknown>;
+    findFormItem?: (prop: string) => FormItemSearchResult | undefined;
+    hasFormItem?: (prop: string) => boolean;
+    registerFormItems?: (provider: FormItemProvider) => () => void;
+    refreshFormItems?: (providerId?: string | symbol) => void;
+}
+export interface Fields {
+    [key: string]: unknown;
+}
+export interface CurdFormOptionItem extends OptionItem {
+    component?: string | ReturnType<typeof defineComponent>;
+    disabled?: boolean;
+    type?: string | "radio" | "button";
+    rawContent?: boolean;
+    /** 引用的表单项 prop 数组，用于 choose 类型 */
+    props?: string[];
+    /** 内联表单项定义，用于 choose 类型 */
+    items?: FormItem[];
+}
+export interface FormItemProvider {
+    id: string | symbol;
+    getItems: () => FormItem[] | undefined | null;
+}
+export interface FormItemSearchResult {
+    item: FormItem;
+    parent?: FormItem;
+    path: string;
+    providerId?: string | symbol;
+}
+export type EventObjectHandler = (formModel: Fields, formItem: FormItem, context?: FormContext, ...args: unknown[]) => void | boolean;
+export interface EventObject {
+    change?: EventObjectHandler;
+    optionLoaded?: EventObjectHandler;
+    [key: string]: EventObjectHandler | undefined;
+}
+export declare const FormItemProps: {
+    formItem: {
+        type: PropType<FormItem>;
+        default: () => {};
+    };
+    formModel: {
+        type: PropType<Fields>;
+        default: () => {};
+    };
+    props: {
+        type: PropType<FormItemPropObject>;
+        default: () => {};
+    };
+    eventObject: {
+        type: PropType<EventObject>;
+        default: () => {};
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+};

package/dist/components/CurdForm/src/types.js

@@ -0,0 +1,27 @@
+import "element-plus";
+import "vue";
+const o = {
+  formItem: {
+    type: Object,
+    default: () => ({})
+  },
+  formModel: {
+    type: Object,
+    default: () => ({})
+  },
+  props: {
+    type: Object,
+    default: () => ({})
+  },
+  eventObject: {
+    type: Object,
+    default: () => ({})
+  },
+  modelValue: {
+    type: String,
+    default: ""
+  }
+};
+export {
+  o as FormItemProps
+};

package/dist/components/CurdForm/src/utils/ajax.d.ts

@@ -0,0 +1,25 @@
+export declare class UploadAjaxError extends Error {
+    name: string;
+    status: number;
+    method: string;
+    url: string;
+    constructor(message: string, status: number, method: string, url: string);
+}
+export declare const ajaxUpload: UploadRequestHandler;
+export declare function throwError(scope: string, m: string): never;
+export interface UploadProgressEvent extends ProgressEvent {
+    percent: number;
+}
+export type UploadRequestHandler = (options: UploadRequestOptions) => XMLHttpRequest | Promise<unknown>;
+export interface UploadRequestOptions {
+    action: string;
+    method: string;
+    data: Record<string, string | Blob | [string | Blob, string]>;
+    filename: string;
+    file: File;
+    headers: Headers | Record<string, string | number | null | undefined>;
+    onError: (evt: UploadAjaxError) => void;
+    onProgress: (evt: UploadProgressEvent) => void;
+    onSuccess: (response: XMLHttpRequestResponseType) => void;
+    withCredentials: boolean;
+}

package/dist/components/CurdForm/src/utils/common.d.ts

@@ -0,0 +1 @@
+export declare function deepClone<T extends Array<T> | unknown>(sourceData: T): T;

package/dist/components/CurdForm/src/utils/common.js

@@ -0,0 +1,13 @@
+function l(n) {
+  if (Array.isArray(n))
+    return n.map((f) => l(f));
+  if (typeof n != "object" || n === null)
+    return n;
+  const i = {};
+  for (const f in n)
+    typeof n[f] == "object" && n[f] !== null ? i[f] = l(n[f]) : i[f] = n[f];
+  return i;
+}
+export {
+  l as deepClone
+};

package/dist/components/CurdGroupForm/index.d.ts

@@ -0,0 +1,2 @@
+export { default as CurdGroupForm } from './src/CurdGroupForm.vue';
+export * from './types';

package/dist/components/CurdGroupForm/src/CurdGroupForm.vue.d.ts

@@ -0,0 +1,36 @@
+import { PropType } from 'vue';
+import { CurdGroupFormSchema } from '../types';
+declare const _default: import('vue').DefineComponent<{
+    modelValue: {
+        type: PropType<Record<string, unknown>>;
+        default: () => {};
+    };
+    schema: {
+        type: PropType<CurdGroupFormSchema>;
+        default: () => {};
+    };
+}, {
+    loadOptions: (prop: string, config?: unknown) => void;
+    validate: (callback: (valid: boolean) => void) => void;
+}, unknown, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (...args: any[]) => void;
+    "update:modelValue": (...args: any[]) => void;
+    loadOptions: (...args: any[]) => void;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    modelValue: {
+        type: PropType<Record<string, unknown>>;
+        default: () => {};
+    };
+    schema: {
+        type: PropType<CurdGroupFormSchema>;
+        default: () => {};
+    };
+}>> & {
+    onChange?: ((...args: any[]) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onLoadOptions?: ((...args: any[]) => any) | undefined;
+}, {
+    modelValue: Record<string, unknown>;
+    schema: CurdGroupFormSchema;
+}, {}>;
+export default _default;

package/dist/components/CurdGroupForm/src/CurdGroupForm.vue.js

@@ -0,0 +1,113 @@
+import { defineComponent as O, watch as g, createElementBlock as B, openBlock as c, Fragment as R, renderList as b, withDirectives as w, createBlock as h, createSlots as N, withCtx as d, createElementVNode as S, createVNode as j, unref as l, isRef as D, resolveDynamicComponent as u, vShow as E } from "vue";
+import { CurdForm as H } from "../../CurdForm/index.js";
+import T from "./components/CurdFormGroup.vue.js";
+import { useFormHook as G } from "./hooks/useFormHook.js";
+const L = {
+  class: "curdform-group-content",
+  "data-instance-form-wrap": ""
+}, J = /* @__PURE__ */ O({
+  __name: "CurdGroupForm",
+  props: {
+    modelValue: {
+      type: Object,
+      default: () => ({})
+    },
+    schema: {
+      type: Object,
+      default: () => ({})
+    }
+  },
+  emits: ["update:modelValue", "change", "loadOptions"],
+  setup(I, { expose: V, emit: _ }) {
+    const o = I, i = _, { form: a, formRef: f, schema: p, validate: k, schemaItemHidden: x } = G();
+    (() => {
+      a.value = o.modelValue || {}, p.value = o.schema;
+    })(), g(
+      () => o.schema,
+      () => {
+        p.value = o.schema;
+      }
+    ), g(
+      () => o.modelValue,
+      () => {
+        a.value != o.modelValue && (a.value = o.modelValue);
+      }
+    );
+    const v = (t, r) => {
+      if (!o.schema) return;
+      let e = !1;
+      for (const n in o.schema.items) {
+        const m = o.schema.items[n], s = f.value[(m.step || "") + m.groupName + n];
+        (s != null && s.hasFormItem ? s.hasFormItem(t) : m.schema.formItem.some((y) => y.prop == t)) && (e = !0, s == null || s.loadOptions(t, r));
+      }
+      e || i("loadOptions", t);
+    }, C = {
+      loadOptions: v
+    }, F = (t, r) => {
+      i("change", t, r);
+    };
+    return V({ loadOptions: v, validate: k }), (t, r) => (c(!0), B(R, null, b(o.schema.items, (e, n) => w((c(), h(T, {
+      key: n,
+      item: e,
+      title: e.groupName,
+      icon: e.icon,
+      "label-position": e.labelPosition
+    }, N({
+      default: d(() => [
+        S("div", L, [
+          j(l(H), {
+            ref_for: !0,
+            ref: (m) => l(f)[(e.step || "") + e.groupName + n] = m,
+            modelValue: l(a),
+            "onUpdate:modelValue": r[0] || (r[0] = (m) => D(a) ? a.value = m : null),
+            "form-schema": e.schema,
+            "extend-context": C,
+            validateOnRuleChange: !1,
+            "scroll-to-error": !0,
+            onChange: F
+          }, null, 8, ["modelValue", "form-schema"])
+        ])
+      ]),
+      _: 2
+    }, [
+      e.headerRight ? {
+        name: "headerRight",
+        fn: d(() => [
+          (c(), h(u(e.headerRight), {
+            schema: o.schema,
+            schemaItem: e,
+            "form-model": l(a)
+          }, null, 8, ["schema", "schemaItem", "form-model"]))
+        ]),
+        key: "0"
+      } : void 0,
+      e.headerTitle ? {
+        name: "title",
+        fn: d(() => [
+          (c(), h(u(e.headerTitle), {
+            schema: o.schema,
+            schemaItem: e,
+            "form-model": l(a)
+          }, null, 8, ["schema", "schemaItem", "form-model"]))
+        ]),
+        key: "1"
+      } : void 0,
+      e.headerBottom ? {
+        name: "headerBottom",
+        fn: d(() => [
+          (c(), h(u(e.headerBottom), {
+            schema: o.schema,
+            schemaItem: e,
+            "form-model": l(a)
+          }, null, 8, ["schema", "schemaItem", "form-model"]))
+        ]),
+        key: "2"
+      } : void 0
+    ]), 1032, ["item", "title", "icon", "label-position"])), [
+      [E, !l(x)(e)]
+    ])), 128));
+  }
+});
+export {
+  J as default
+};

package/dist/components/CurdGroupForm/src/CurdGroupForm.vue2.js

@@ -0,0 +1,4 @@
+import f from "./CurdGroupForm.vue.js";
+export {
+  f as default
+};