@vunk/form 0.0.1-alpha.21 → 0.0.1-alpha.23

package/composables/index.js

@@ -1,4 +1,4 @@
-import { isRef, ref, computed, unref } from 'vue';
+import { isRef, ref, computed as computed$1, unref, inject } from 'vue';
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;
@@ -27,9 +27,10 @@ const useSourceManager = (source, opts = {}) => {
     slotsChildren: ["default"]
   });
   opts.slotsChildren && op.slotsChildren.push(...opts.slotsChildren);
-  const manager = computed(() => {
+  const manager = computed$1(() => {
     const keyRecord = {};
     const propRecord = {};
+    const idRecord = {};
     function intoData(list, k = []) {
       list.forEach((item, index) => {
         const currentK = [...k, index];
@@ -37,12 +38,16 @@ const useSourceManager = (source, opts = {}) => {
           source: item,
           key: currentK,
           nextKey: [...k, index + 1],
-          prop: item.prop
+          prop: item.prop,
+          id: item.id
         };
         keyRecord[currentK.join()] = managerInfo;
         if (item.prop) {
           propRecord[item.prop] = managerInfo;
         }
+        if (item.id) {
+          idRecord[item.id] = managerInfo;
+        }
         if (item.templateSlots) {
           if (Array.isArray(item.templateSlots)) {
             currentK.push("templateSlots");
@@ -60,23 +65,329 @@ const useSourceManager = (source, opts = {}) => {
     intoData(unref(source));
     return {
       keyRecord,
-      propRecord
+      propRecord,
+      idRecord
     };
   });
   const getManagerInfoByProp = (prop) => {
     return manager.value.propRecord[prop];
   };
   const getManagerInfoByKey = (key) => {
-    return manager.value.propRecord[key.join()];
+    return manager.value.keyRecord[key.join()];
+  };
+  const getManagerInfoById = (id) => {
+    return manager.value.idRecord[id];
   };
   return [
     source,
     {
       manager,
       getManagerInfoByProp,
-      getManagerInfoByKey
+      getManagerInfoByKey,
+      getManagerInfoById
     }
   ];
 };
 
-export { useSourceManager };
+/**
+ * Make a map and return a function for checking if a key
+ * is in that map.
+ * IMPORTANT: all calls of this function must be prefixed with
+ * \/\*#\_\_PURE\_\_\*\/
+ * So that rollup can tree-shake them if necessary.
+ */
+
+(process.env.NODE_ENV !== 'production')
+    ? Object.freeze({})
+    : {};
+(process.env.NODE_ENV !== 'production') ? Object.freeze([]) : [];
+const NOOP = () => { };
+const extend = Object.assign;
+const isArray = Array.isArray;
+const isFunction = (val) => typeof val === 'function';
+const isSymbol = (val) => typeof val === 'symbol';
+
+let activeEffectScope;
+function recordEffectScope(effect, scope = activeEffectScope) {
+    if (scope && scope.active) {
+        scope.effects.push(effect);
+    }
+}
+
+const createDep = (effects) => {
+    const dep = new Set(effects);
+    dep.w = 0;
+    dep.n = 0;
+    return dep;
+};
+const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
+const newTracked = (dep) => (dep.n & trackOpBit) > 0;
+const initDepMarkers = ({ deps }) => {
+    if (deps.length) {
+        for (let i = 0; i < deps.length; i++) {
+            deps[i].w |= trackOpBit; // set was tracked
+        }
+    }
+};
+const finalizeDepMarkers = (effect) => {
+    const { deps } = effect;
+    if (deps.length) {
+        let ptr = 0;
+        for (let i = 0; i < deps.length; i++) {
+            const dep = deps[i];
+            if (wasTracked(dep) && !newTracked(dep)) {
+                dep.delete(effect);
+            }
+            else {
+                deps[ptr++] = dep;
+            }
+            // clear bits
+            dep.w &= ~trackOpBit;
+            dep.n &= ~trackOpBit;
+        }
+        deps.length = ptr;
+    }
+};
+// The number of effects currently being tracked recursively.
+let effectTrackDepth = 0;
+let trackOpBit = 1;
+/**
+ * The bitwise track markers support at most 30 levels of recursion.
+ * This value is chosen to enable modern JS engines to use a SMI on all platforms.
+ * When recursion depth is greater, fall back to using a full cleanup.
+ */
+const maxMarkerBits = 30;
+let activeEffect;
+Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : '');
+Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : '');
+class ReactiveEffect {
+    constructor(fn, scheduler = null, scope) {
+        this.fn = fn;
+        this.scheduler = scheduler;
+        this.active = true;
+        this.deps = [];
+        this.parent = undefined;
+        recordEffectScope(this, scope);
+    }
+    run() {
+        if (!this.active) {
+            return this.fn();
+        }
+        let parent = activeEffect;
+        let lastShouldTrack = shouldTrack;
+        while (parent) {
+            if (parent === this) {
+                return;
+            }
+            parent = parent.parent;
+        }
+        try {
+            this.parent = activeEffect;
+            activeEffect = this;
+            shouldTrack = true;
+            trackOpBit = 1 << ++effectTrackDepth;
+            if (effectTrackDepth <= maxMarkerBits) {
+                initDepMarkers(this);
+            }
+            else {
+                cleanupEffect(this);
+            }
+            return this.fn();
+        }
+        finally {
+            if (effectTrackDepth <= maxMarkerBits) {
+                finalizeDepMarkers(this);
+            }
+            trackOpBit = 1 << --effectTrackDepth;
+            activeEffect = this.parent;
+            shouldTrack = lastShouldTrack;
+            this.parent = undefined;
+            if (this.deferStop) {
+                this.stop();
+            }
+        }
+    }
+    stop() {
+        // stopped while running itself - defer the cleanup
+        if (activeEffect === this) {
+            this.deferStop = true;
+        }
+        else if (this.active) {
+            cleanupEffect(this);
+            if (this.onStop) {
+                this.onStop();
+            }
+            this.active = false;
+        }
+    }
+}
+function cleanupEffect(effect) {
+    const { deps } = effect;
+    if (deps.length) {
+        for (let i = 0; i < deps.length; i++) {
+            deps[i].delete(effect);
+        }
+        deps.length = 0;
+    }
+}
+let shouldTrack = true;
+function trackEffects(dep, debuggerEventExtraInfo) {
+    let shouldTrack = false;
+    if (effectTrackDepth <= maxMarkerBits) {
+        if (!newTracked(dep)) {
+            dep.n |= trackOpBit; // set newly tracked
+            shouldTrack = !wasTracked(dep);
+        }
+    }
+    else {
+        // Full cleanup mode.
+        shouldTrack = !dep.has(activeEffect);
+    }
+    if (shouldTrack) {
+        dep.add(activeEffect);
+        activeEffect.deps.push(dep);
+        if ((process.env.NODE_ENV !== 'production') && activeEffect.onTrack) {
+            activeEffect.onTrack(Object.assign({ effect: activeEffect }, debuggerEventExtraInfo));
+        }
+    }
+}
+function triggerEffects(dep, debuggerEventExtraInfo) {
+    // spread into array for stabilization
+    const effects = isArray(dep) ? dep : [...dep];
+    for (const effect of effects) {
+        if (effect.computed) {
+            triggerEffect(effect, debuggerEventExtraInfo);
+        }
+    }
+    for (const effect of effects) {
+        if (!effect.computed) {
+            triggerEffect(effect, debuggerEventExtraInfo);
+        }
+    }
+}
+function triggerEffect(effect, debuggerEventExtraInfo) {
+    if (effect !== activeEffect || effect.allowRecurse) {
+        if ((process.env.NODE_ENV !== 'production') && effect.onTrigger) {
+            effect.onTrigger(extend({ effect }, debuggerEventExtraInfo));
+        }
+        if (effect.scheduler) {
+            effect.scheduler();
+        }
+        else {
+            effect.run();
+        }
+    }
+}
+new Set(
+/*#__PURE__*/
+Object.getOwnPropertyNames(Symbol)
+    // ios10.x Object.getOwnPropertyNames(Symbol) can enumerate 'arguments' and 'caller'
+    // but accessing them on Symbol leads to TypeError because Symbol is a strict mode
+    // function
+    .filter(key => key !== 'arguments' && key !== 'caller')
+    .map(key => Symbol[key])
+    .filter(isSymbol));
+function toRaw(observed) {
+    const raw = observed && observed["__v_raw" /* RAW */];
+    return raw ? toRaw(raw) : observed;
+}
+
+function trackRefValue(ref) {
+    if (shouldTrack && activeEffect) {
+        ref = toRaw(ref);
+        if ((process.env.NODE_ENV !== 'production')) {
+            trackEffects(ref.dep || (ref.dep = createDep()), {
+                target: ref,
+                type: "get" /* GET */,
+                key: 'value'
+            });
+        }
+        else {
+            trackEffects(ref.dep || (ref.dep = createDep()));
+        }
+    }
+}
+function triggerRefValue(ref, newVal) {
+    ref = toRaw(ref);
+    if (ref.dep) {
+        if ((process.env.NODE_ENV !== 'production')) {
+            triggerEffects(ref.dep, {
+                target: ref,
+                type: "set" /* SET */,
+                key: 'value',
+                newValue: newVal
+            });
+        }
+        else {
+            triggerEffects(ref.dep);
+        }
+    }
+}
+
+class ComputedRefImpl {
+    constructor(getter, _setter, isReadonly, isSSR) {
+        this._setter = _setter;
+        this.dep = undefined;
+        this.__v_isRef = true;
+        this._dirty = true;
+        this.effect = new ReactiveEffect(getter, () => {
+            if (!this._dirty) {
+                this._dirty = true;
+                triggerRefValue(this);
+            }
+        });
+        this.effect.computed = this;
+        this.effect.active = this._cacheable = !isSSR;
+        this["__v_isReadonly" /* IS_READONLY */] = isReadonly;
+    }
+    get value() {
+        // the computed ref may get wrapped by other proxies e.g. readonly() #3376
+        const self = toRaw(this);
+        trackRefValue(self);
+        if (self._dirty || !self._cacheable) {
+            self._dirty = false;
+            self._value = self.effect.run();
+        }
+        return self._value;
+    }
+    set value(newValue) {
+        this._setter(newValue);
+    }
+}
+function computed(getterOrOptions, debugOptions, isSSR = false) {
+    let getter;
+    let setter;
+    const onlyGetter = isFunction(getterOrOptions);
+    if (onlyGetter) {
+        getter = getterOrOptions;
+        setter = (process.env.NODE_ENV !== 'production')
+            ? () => {
+                console.warn('Write operation failed: computed value is readonly');
+            }
+            : NOOP;
+    }
+    else {
+        getter = getterOrOptions.get;
+        setter = getterOrOptions.set;
+    }
+    const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
+    if ((process.env.NODE_ENV !== 'production') && debugOptions && !isSSR) {
+        cRef.effect.onTrack = debugOptions.onTrack;
+        cRef.effect.onTrigger = debugOptions.onTrigger;
+    }
+    return cRef;
+}
+
+const useForm = () => {
+  return inject("vkfFormVm", null);
+};
+const useComputedReadonly = (props) => {
+  const form = useForm();
+  const readonly = computed(() => {
+    var _a, _b;
+    return (_b = (_a = props.readonly) != null ? _a : form == null ? void 0 : form.props.readonly) != null ? _b : false;
+  });
+  return readonly;
+};
+
+export { useComputedReadonly, useForm, useSourceManager };

package/composables/useForm.d.ts

@@ -0,0 +1,9 @@
+import { ComponentInternalInstance, ComputedRef } from 'vue';
+import { VkfForm } from '@vunk/form/components/form';
+import { VueComponentPropsType } from '@vunk/core';
+export declare const useForm: () => (ComponentInternalInstance & {
+    props: VueComponentPropsType<typeof VkfForm>;
+}) | null;
+export declare const useComputedReadonly: (props: {
+    readonly?: boolean;
+}) => ComputedRef<boolean>;

package/composables/useSourceManager.d.ts

@@ -7,7 +7,9 @@ export declare const useSourceManager: <T = FormItemRendererSource<string>>(sour
     readonly manager: import("vue").ComputedRef<{
         keyRecord: Record<string, ManagerInfo<T>>;
         propRecord: Record<string, ManagerInfo<T>>;
+        idRecord: Record<string, ManagerInfo<T>>;
     }>;
     readonly getManagerInfoByProp: <I = T>(prop: string) => ManagerInfo<I>;
     readonly getManagerInfoByKey: <I_1 = T>(key: (string | number)[]) => ManagerInfo<I_1>;
+    readonly getManagerInfoById: <I_2 = T>(id: string) => ManagerInfo<I_2>;
 }];

package/index.css

@@ -1,4 +1,43 @@
 
+.el-checkbox-group.is-readonly .el-checkbox,
+.el-checkbox-group.is-readonly{
+  --el-readonly-cursor: auto;
+  --el-disabled-text-color: var(--el-checkbox-text-color);
+  --el-checkbox-disabled-checked-input-fill: var(--el-checkbox-bg-color);
+  --el-checkbox-disabled-checked-icon-color: var(--el-checkbox-checked-icon-color);
+}
+
+
+.el-checkbox-group.is-readonly .el-checkbox__input.is-checked+.el-checkbox__label {
+  color: var(--el-checkbox-checked-text-color);
+}
+.el-checkbox-group.is-readonly .el-checkbox__input.is-checked .el-checkbox__inner {
+    background-color: var(--el-checkbox-checked-bg-color);
+    border-color: var(--el-checkbox-checked-input-border-color);
+}
+.el-checkbox-group.is-readonly .el-checkbox__input.is-disabled+span.el-checkbox__label,
+.el-checkbox-group.is-readonly .el-checkbox__input.is-disabled .el-checkbox__inner {
+  cursor: var(--el-readonly-cursor);
+}
+
+
+
+.el-checkbox-group.is-readonly .el-checkbox-button.is-checked:first-child .el-checkbox-button__inner{
+  border-left-color: var(--el-checkbox-button-checked-border-color);
+}
+
+.el-checkbox-group.is-readonly .el-checkbox-button.is-checked .el-checkbox-button__inner {
+    color: var(--el-checkbox-button-checked-text-color);
+    background-color: var(--el-checkbox-button-checked-bg-color);
+    border-color: var(--el-checkbox-button-checked-border-color);
+    box-shadow: -1px 0 0 0 var(--el-color-primary-light-7);
+}
+
+.el-checkbox-group.is-readonly .el-checkbox-button.is-disabled .el-checkbox-button__inner{
+  cursor: var(--el-readonly-cursor);
+}
+
+
 .vkf-form-item--inline{
   display: inline-flex;
 }
@@ -11,6 +50,85 @@
   width: 100%;
 }
 
+
+.el-input-number.is-readonly{
+  --el-readonly-cursor: text;
+  --el-disabled-bg-color: initial;
+  --el-disabled-text-color: var(--el-input-text-color);
+}
+.el-input-number.is-readonly .el-input-number__decrease, 
+.el-input-number.is-readonly .el-input-number__increase{
+  display: none;
+}
+.el-input-number.is-readonly .el-input.is-disabled,
+.el-input-number.is-readonly .el-input.is-disabled .el-input__inner{
+  cursor: var(--el-readonly-cursor);
+}
+
+
+.el-radio-group.is-readonly,
+.el-radio-group.is-readonly .el-radio-button{
+  --el-readonly-cursor: auto;
+  --el-disabled-bg-color: initial;
+  --el-disabled-text-color: initial;
+  --el-radio-button-disabled-checked-fill: var(--el-radio-button-checked-bg-color);
+}
+
+.el-radio-group.is-readonly .is-active .el-radio-button__original-radio:disabled+.el-radio-button__inner{
+  color: var(--el-radio-button-checked-text-color);
+}
+.el-radio-group.is-readonly .el-radio-button__original-radio:disabled+.el-radio-button__inner {
+  cursor: var(--el-readonly-cursor);
+}
+
+.el-radio-group.is-readonly  .el-radio__input.is-checked+.el-radio__label{
+ color: var(--el-color-primary);
+}
+.el-radio-group.is-readonly .el-radio__input.is-checked .el-radio__inner {
+  border-color: var(--el-color-primary);
+  background: var(--el-color-primary);
+
+}
+.el-radio-group.is-readonly .el-radio__input .el-radio__inner,
+.el-radio-group.is-readonly .el-radio__input.is-disabled+span.el-radio__label {
+ cursor: var(--el-readonly-cursor);
+}
+ 
+
+
+.el-select.is-readonly{
+  --el-readonly-cursor: text;
+  --el-disabled-bg-color: initial;
+  --el-disabled-text-color: var(--el-input-text-color);
+}
+.el-select.is-readonly .el-input.is-disabled .el-input__inner,
+.el-select.is-readonly .el-input.is-disabled .el-select__caret,
+.el-select.is-readonly .el-input.is-disabled .el-input__wrapper{
+  cursor: var(--el-readonly-cursor);
+}
+
+
+.el-switch.is-readonly{
+ --el-readonly-cursor: auto;
+}
+.el-switch.is-readonly.is-readonly{
+  opacity: .9;
+}
+.el-switch.is-readonly.is-readonly .el-switch__core, 
+.el-switch.is-readonly.is-readonly .el-switch__label{
+  cursor: var(--el-readonly-cursor);
+}
+
+
+
+.vkf-upload.is-readonly .el-upload,
+.vkf-upload.is-readonly .el-upload{
+  display: none;
+}
+.vkf-upload .el-upload-list{
+  min-width: 100px;
+}
+
 
 .el-upload-list__item-status-label{
   z-index: 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vunk/form",
-  "version": "0.0.1-alpha.21",
+  "version": "0.0.1-alpha.23",
   "description": "",
   "main": "index.esm.js",
   "scripts": {