@leyyo/env 1.0.13 → 1.2.1

package/dist/field/index.types.d.ts

@@ -1,152 +1,165 @@
-import type { EnvScopeConfigure, EnvScopeRuntime } from "../scope";
+import type { EnvScopeConfigure, EnvScopeRuntime, EnvVariation, EnvVariationValue } from "../scope";
 import type { EnvBase } from "../core";
-import type { DevOpt, EnumMap, KeyValue } from "@leyyo/common";
-import type { EnumLiteral } from "@leyyo/common/dist/shared/index.types";
-export type EnvFieldCastLambda<E extends EnvBase = EnvBase, Z extends keyof E = keyof E> = (v: unknown) => E[Z];
-export type EnvFieldAssertLambda = (v: unknown) => void;
+import type { EnumLiteral, EnumMap, KeyValue } from "@leyyo/common";
+import type { AssertBasicFn, ToLambda } from "@leyyo/type";
+/**
+ * Field types
+ * */
 export type EnvFieldType = 'string' | 'text' | 'float' | 'integer' | 'boolean' | 'literal' | 'enumeration';
-export interface EnvFieldArray {
-    char?: ',' | ';' | '/' | '|' | string;
-    min?: number;
-    max?: number;
-    unique?: boolean;
-}
-export interface EnvFieldSecret {
-    type?: EnvFieldSecretType;
-}
-export type EnvFieldSecretType = 'password' | 'token' | 'private-key' | 'public-key' | 'api-key' | 'host';
-export interface EnvFieldString {
-    min?: number;
-    max?: number;
-    pattern?: string | RegExp;
-}
-export interface EnvFieldFloat {
-    min?: number;
-    max?: number;
-}
-export interface EnvFieldInteger {
-    min?: number;
-    max?: number;
-    modulus?: number;
-}
-export interface EnvFieldBoolean {
-    yes?: string[];
-    no?: string[];
-}
+/**
+ * Printable field object
+ * */
 export interface EnvFieldPrint {
+    /**
+     * Name of scope
+     * */
     scope: string;
+    /**
+     * Key of field
+     * */
     key: string;
+    /**
+     * Value of field
+     * */
     value?: any;
+    /**
+     * Type of field
+     * */
     type: EnvFieldType;
+    /**
+     * Other info about field
+     * */
     opt?: Record<string, unknown>;
 }
-export interface EnvFieldConfigure<E extends EnvBase = EnvBase, Z extends keyof E = keyof E> {
+/**
+ * Environment field, configuration mode
+ *
+ * Generics:
+ * - C: Environment interface
+ * - P: Prefix for environment
+ * - A: Variation
+ * - Z: field name
+ * */
+export interface EnvFieldConfigure<C extends EnvBase, P extends string, A extends string, Z extends keyof C = keyof C> {
     /**
      * Shift to runtime mode
      * */
-    get runtime(): EnvFieldRuntime<E, Z>;
+    get runtime(): EnvFieldRuntime<C, P, A, Z>;
     /**
      * Key is required
      * */
-    required(): EnvFieldConfigure<E, Z>;
+    required(): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Key is required or not
      * */
-    required(flag: boolean): EnvFieldConfigure<E, Z>;
+    required(flag: boolean): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Key is required by given condition
      * */
-    required(fn: EnvFieldOnLambda<E, Z, boolean>): EnvFieldConfigure<E, Z>;
+    required(fn: EnvFieldOnLambda<C, P, A, Z, boolean>): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Key is array, so value is split by char
      * */
-    array(opt?: EnvFieldArray): EnvFieldConfigure<E, Z>;
+    array(): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Key is secret value
      * */
-    secret(opt?: EnvFieldSecret): EnvFieldConfigure<E, Z>;
+    secret(): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Cloned key
      * */
-    clone(name: string): EnvFieldConfigure<E, Z>;
+    clone(name: string): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Set default value
      * */
-    def(value: E[Z] | EnvFieldOnLambda<E, Z, E[Z]>): EnvFieldConfigure<E, Z>;
+    def(value: C[Z] | EnvFieldOnLambda<C, P, A, Z, C[Z]>): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Value may have another aliases
      * */
-    alias(...keys: string[]): EnvFieldConfigure<E, Z>;
+    alias(...keys: string[]): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Value is string (can be empty)
      * */
-    string(opt?: EnvFieldString): EnvFieldConfigure<E, Z>;
+    string(): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Value is text (can not be empty)
      * */
-    text(opt?: EnvFieldString): EnvFieldConfigure<E, Z>;
+    text(): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Value is float
      * */
-    float(opt?: EnvFieldFloat): EnvFieldConfigure<E, Z>;
+    float(): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Value is integer
      * */
-    integer(opt?: EnvFieldInteger): EnvFieldConfigure<E, Z>;
+    integer(): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Value is boolean
      * */
-    boolean(opt?: EnvFieldBoolean): EnvFieldConfigure<E, Z>;
+    boolean(): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Value is literal
      * */
-    literal<L extends KeyValue = string>(keys: EnumLiteral<L>): EnvFieldConfigure<E, Z>;
+    literal<L extends KeyValue = string>(keys: EnumLiteral<L>): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Value is enumeration
      * */
-    enumeration<L extends KeyValue = string>(map: EnumMap<L>): EnvFieldConfigure<E, Z>;
+    enumeration<L extends KeyValue = string>(map: EnumMap<L>): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Emit an event when ota is occurred
      * */
-    onOta(fn?: EnvFieldOnLambda<E, Z, void>): EnvFieldConfigure<E, Z>;
+    onOta(fn?: EnvFieldOnLambda<C, P, A, Z, void>): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Emit an event when value is changed
      * */
-    onChange(fn: EnvFieldOnLambda<E, Z, void>): EnvFieldConfigure<E, Z>;
+    onChange(fn: EnvFieldOnLambda<C, P, A, Z, void>): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Emit an event when value is set
      * */
-    onSet(fn: EnvFieldOnLambda<E, Z, void>): EnvFieldConfigure<E, Z>;
+    onSet(fn: EnvFieldOnLambda<C, P, A, Z, void>): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Set cast function, please take attention
      * */
-    cast(fn: EnvFieldCastLambda<E, Z>): EnvFieldConfigure<E, Z>;
+    cast(fn: ToLambda<C[Z]>): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Set asset function, please take attention
      * */
-    assert(fn: EnvFieldAssertLambda): EnvFieldConfigure<E, Z>;
+    assert(fn: AssertBasicFn): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Go back to scope
      * */
-    get end(): EnvScopeConfigure<E>;
+    end(): EnvScopeConfigure<C, P, A>;
 }
-export interface EnvFieldRuntime<E extends EnvBase = EnvBase, Z extends keyof E = keyof E> {
+/**
+ * Environment field, runtime mode
+ *
+ * Generics:
+ * - C: Environment interface
+ * - P: Prefix for environment
+ * - A: Variation
+ * - Z: field name
+ * */
+export interface EnvFieldRuntime<C extends EnvBase, P extends string, A extends string, Z extends keyof C = keyof C> {
     /**
      * Scope
      * */
-    readonly scope: EnvScopeRuntime<E>;
+    readonly scope: EnvScopeRuntime<C, P, A>;
     /**
      * Name of field
      * */
     readonly name: Z;
+    /**
+     * Full name of field
+     * */
+    readonly full: keyof EnvVariation<C, P, A>;
     /**
      * Shift to configure mode
      * */
-    get configure(): EnvFieldConfigure<E, Z>;
+    get configure(): EnvFieldConfigure<C, P, A, Z>;
     /**
      * Shift to secure mode
      * */
-    get $secure(): EnvFieldSecure<E, Z>;
+    get $secure(): EnvFieldSecure<C, P, A, Z>;
     /**
      * Read value, and call cast (if defined), assert (if defined), onChanged (if changed), onSet (if exists)
      * */
@@ -156,9 +169,9 @@ export interface EnvFieldRuntime<E extends EnvBase = EnvBase, Z extends keyof E
      * */
     print(): EnvFieldPrint;
     /**
-     * Return raw value
+     * Return value
      * */
-    get raw(): E[Z] | undefined;
+    get value(): EnvVariationValue<C, P, A, Z> | undefined;
     /**
      * Value is being set from ota
      * */
@@ -166,13 +179,22 @@ export interface EnvFieldRuntime<E extends EnvBase = EnvBase, Z extends keyof E
     /**
      * Set value with all controls
      * */
-    set(value: E[Z]): void;
+    set(value: C[Z]): void;
 }
-export interface EnvFieldSecure<E extends EnvBase = EnvBase, Z extends keyof E = keyof E> {
+/**
+ * Environment field, secure mode
+ *
+ * Generics:
+ * - C: Environment interface
+ * - P: Prefix for environment
+ * - A: Variation
+ * - Z: field name
+ * */
+export interface EnvFieldSecure<C extends EnvBase, P extends string, A extends string, Z extends keyof C = keyof C> {
     /**
      * Shift to runtime mode
      * */
-    get runtime(): EnvFieldRuntime<E, Z>;
+    get runtime(): EnvFieldRuntime<C, P, A, Z>;
     /**
      * Set value without any control
      * */
@@ -180,23 +202,33 @@ export interface EnvFieldSecure<E extends EnvBase = EnvBase, Z extends keyof E =
     /**
      * Set cast function without any control
      * */
-    $cast(fn: EnvFieldCastLambda<E, Z>): void;
+    $cast(fn: ToLambda<C[Z]>): void;
     /**
      * Set asset function without any control
      * */
-    $assert(fn: EnvFieldAssertLambda): void;
-}
-export interface EnvField<E extends EnvBase = EnvBase, Z extends keyof E = keyof E> extends EnvFieldConfigure<E, Z>, EnvFieldRuntime<E, Z>, EnvFieldSecure<E, Z> {
+    $assert(fn: AssertBasicFn): void;
 }
-export type EnvFieldCastBasicLambda<T> = (value: unknown, opt: DevOpt, required: boolean) => T | undefined;
-export type EnvFieldCastEnumLambda<T extends KeyValue> = (value: unknown, keys: unknown, opt: DevOpt, required: boolean) => T | undefined;
-export type EnvFieldOnLambda<E extends EnvBase = EnvBase, Z extends keyof E = keyof E, R = unknown> = (field?: EnvFieldRuntime<E, Z>) => R;
-export interface EnvFieldLambdaItem {
-    string: EnvFieldCastBasicLambda<string>;
-    text: EnvFieldCastBasicLambda<string>;
-    float: EnvFieldCastBasicLambda<number>;
-    integer: EnvFieldCastBasicLambda<number>;
-    boolean: EnvFieldCastBasicLambda<boolean>;
-    literal: EnvFieldCastEnumLambda<KeyValue>;
-    enumeration: EnvFieldCastEnumLambda<KeyValue>;
+/**
+ * Environment field, all modes
+ *
+ * Generics:
+ * - C: Environment interface
+ * - P: Prefix for environment
+ * - A: Variation
+ * - Z: field name
+ * */
+export interface EnvField<C extends EnvBase, P extends string, A extends string, Z extends keyof C = keyof C> extends EnvFieldConfigure<C, P, A, Z>, EnvFieldRuntime<C, P, A, Z>, EnvFieldSecure<C, P, A, Z> {
 }
+/**
+ * Environment field on lambda
+ *
+ * Generics:
+ * - C: Environment interface
+ * - P: Prefix for environment
+ * - A: Variation
+ * - Z: field name
+ *
+ * @param {EnvFieldRuntime} field
+ * @return {any}
+ * */
+export type EnvFieldOnLambda<C extends EnvBase, P extends string, A extends string, Z extends keyof C = keyof C, R = unknown> = (field?: EnvFieldRuntime<C, P, A, Z>) => R;

package/dist/scope/env-scope.impl.d.ts

@@ -1,10 +1,13 @@
-import type { EnvBase, EnvCoreRuntime } from "../core";
+import { type EnvBase, type EnvCoreRuntime } from "../core";
 import type { EnvFieldConfigure, EnvFieldRuntime } from "../field";
-import { EnvScope, EnvScopeConfigure, EnvScopeOnLambda, EnvScopePrint, EnvScopeRuntime, EnvScopeSecure } from "./index.types";
-export declare class EnvScopeImpl<E extends EnvBase = EnvBase> implements EnvScope<E> {
+import type { EnvScope, EnvScopeConfigure, EnvScopeOnLambda, EnvScopePrint, EnvScopeRuntime, EnvScopeSecure, EnvVariation } from "./index.types";
+export declare class EnvScopeImpl<C extends EnvBase = EnvBase, P extends string = string, A extends string = undefined> implements EnvScope<C, P, A> {
     readonly core: EnvCoreRuntime;
     readonly name: string;
-    private _raw;
+    readonly prefix: P;
+    readonly variation: A | undefined;
+    private _valueFull;
+    private _valueShort;
     private _run;
     private readonly _fields;
     private readonly _otaList;
@@ -13,29 +16,34 @@ export declare class EnvScopeImpl<E extends EnvBase = EnvBase> implements EnvSco
     private _onChangeList;
     private _onSet;
     private _state;
-    constructor(core: EnvCoreRuntime, name: string);
-    field<Z extends keyof E = keyof E>(name: Z): EnvFieldConfigure<E, Z>;
-    uses<E2 extends EnvBase = EnvBase>(p1: string | EnvScopeRuntime<E2>): EnvScopeConfigure<E>;
-    onChange(fn: EnvScopeOnLambda<E, void>): EnvScopeConfigure<E>;
-    onSet(fn: EnvScopeOnLambda<E, void>): EnvScopeConfigure<E>;
-    onOta(fn: EnvScopeOnLambda<E, void>): EnvScopeConfigure<E>;
-    getField<Z extends keyof E = keyof E>(name: Z): EnvFieldRuntime<E, Z>;
-    hasField<Z extends keyof E = keyof E>(name: Z): boolean;
+    constructor(core: EnvCoreRuntime, name: string, prefix: P, variation: A | undefined);
+    field<Z extends keyof C = keyof C>(name: Z): EnvFieldConfigure<C, P, A, Z>;
+    uses<C2 extends EnvBase = EnvBase, P2 extends string = string, A2 extends string = undefined>(p1: string | EnvScopeRuntime<C2, P2, A2>): EnvScopeConfigure<C, P, A>;
+    onChange(fn: EnvScopeOnLambda<C, P, A, void>): EnvScopeConfigure<C, P, A>;
+    onSet(fn: EnvScopeOnLambda<C, P, A, void>): EnvScopeConfigure<C, P, A>;
+    onOta(fn: EnvScopeOnLambda<C, P, A, void>): EnvScopeConfigure<C, P, A>;
+    getField<Z extends keyof C = keyof C>(name: Z): EnvFieldRuntime<C, P, A, Z>;
+    hasField<Z extends keyof C = keyof C>(name: Z): boolean;
     hasUse(name: string): boolean;
     validUse(name: string): boolean;
     read(): void;
     print(asObject?: boolean): string | EnvScopePrint[];
-    get raw(): E;
+    private _readAgain;
+    get valueFull(): EnvVariation<C, P, A>;
+    get valueShort(): C;
     refresh(): void;
     clear(): void;
     get useList(): Record<string, boolean>;
-    fromOta(values: Partial<E>): void;
+    fromOta(values: Partial<EnvVariation<C, P, A>>): void;
     $read(): void;
     $print(): EnvScopePrint;
-    $addOta(name: keyof E): void;
-    get runtime(): EnvScopeRuntime<E>;
-    get configure(): EnvScopeConfigure<E>;
-    get $secure(): EnvScopeSecure<E>;
-    get begin(): EnvScopeConfigure<E>;
-    get end(): EnvScopeRuntime<E>;
+    $addOta(name: keyof C): void;
+    get runtime(): EnvScopeRuntime<C, P, A>;
+    get configure(): EnvScopeConfigure<C, P, A>;
+    get $secure(): EnvScopeSecure<C, P, A>;
+    private _getVariationName;
+    newVariation<A2 extends string = undefined>(variation: A2): EnvScopeConfigure<C, P, A2>;
+    getVariation<A2 extends string = undefined>(variation: A2): EnvScopeRuntime<C, P, A2>;
+    finish(): EnvScopeRuntime<C, P, A>;
+    start(): EnvScopeConfigure<C, P, A>;
 }

package/dist/scope/env-scope.impl.js

@@ -5,12 +5,16 @@ const internal_1 = require("../internal");
 const common_1 = require("@leyyo/common");
 const env_field_impl_1 = require("../field/env-field.impl");
 const error_enveloper_1 = require("@leyyo/error-enveloper");
+const core_1 = require("../core");
+const type_1 = require("@leyyo/type");
 const WHERE = `${internal_1.FQN}.EnvScopeImpl`;
 class EnvScopeImpl {
     // endregion property
-    constructor(core, name) {
+    constructor(core, name, prefix, variation) {
         this.core = core;
         this.name = name;
+        this.prefix = prefix;
+        this.variation = variation;
         this._fields = common_1.$repo.newMap(WHERE, 'fields'); // field name x field instance
         this._otaList = common_1.$repo.newArray(WHERE, 'otaList'); // field name
         this._uses = common_1.$repo.newMap(WHERE, 'uses'); // scope name x scope instance
@@ -18,11 +22,12 @@ class EnvScopeImpl {
     }
     // region configure
     field(name) {
-        common_1.$assert.text(name, () => {
-            return { where: WHERE, scope: this.name, method: 'field' };
-        });
+        if (this.variation) {
+            throw new core_1.EnvironmentError('varied.scope.does.not.support', `Scope[${this.name}] does not support to create new field`, { scope: this.name, where: WHERE, method: 'finish' });
+        }
+        (0, type_1.assertText)(name, () => common_1.$opt.fn({ where: WHERE, scope: this.name, method: 'field' }));
         if (this._fields.has(name)) {
-            throw common_1.$dev.developerError2(internal_1.FQN, 701, { message: 'Field is duplicated', where: WHERE, scope: this.name, method: 'field', field: name });
+            throw new core_1.EnvironmentError('field.duplicated', `Field[${name}] is duplicated`, { where: WHERE, scope: this.name, method: 'field', field: name });
         }
         const ins = new env_field_impl_1.EnvFieldImpl(this, name);
         this._fields.set(name, ins);
@@ -40,20 +45,20 @@ class EnvScopeImpl {
                 scope.$secure.$read();
             }
             else {
-                common_1.$dev.log({ message: 'Not found scope', given: name, where: WHERE, scope: this.name }, 'warn');
+                logger.warn('Not found scope', { given: name, where: WHERE, scope: this.name });
             }
             if (this._uses.has(name)) {
-                common_1.$dev.log({ message: 'Duplicated used scope', given: name, where: WHERE, scope: this.name }, 'warn');
+                logger.warn('Duplicated used scope', { given: name, where: WHERE, scope: this.name });
             }
             else {
                 this._uses.set(name, scope);
             }
         }
-        else if (common_1.$is.object(p1) && p1 instanceof EnvScopeImpl) {
+        else if ((0, type_1.isObjectValid)(p1) && p1 instanceof EnvScopeImpl) {
             scope = p1;
             name = scope.name;
             if (this._uses.has(name)) {
-                common_1.$dev.log({ message: 'Duplicated used scope', given: name, where: WHERE, scope: this.name }, 'warn');
+                logger.warn('Duplicated used scope', { given: name, where: WHERE, scope: this.name });
             }
             else {
                 this._uses.set(name, scope);
@@ -61,12 +66,12 @@ class EnvScopeImpl {
             }
         }
         else {
-            common_1.$dev.log({ message: 'Invalid scope', type: typeof p1, clazz: (_a = p1 === null || p1 === void 0 ? void 0 : p1.constructor) === null || _a === void 0 ? void 0 : _a.name, where: WHERE, scope: this.name }, 'warn');
+            logger.warn('Invalid used scope', { type: typeof p1, clazz: (_a = p1 === null || p1 === void 0 ? void 0 : p1.constructor) === null || _a === void 0 ? void 0 : _a.name, where: WHERE, scope: this.name });
         }
         return this;
     }
     onChange(fn) {
-        common_1.$assert.func(fn, { where: WHERE, scope: this.name, method: 'onChange' });
+        (0, type_1.assertFunction)(fn, () => common_1.$opt.fn({ where: WHERE, scope: this.name, method: 'onChange' }));
         if (!Array.isArray(this._onChangeList)) {
             this._onChangeList = [];
         }
@@ -74,36 +79,30 @@ class EnvScopeImpl {
         return this;
     }
     onSet(fn) {
-        common_1.$assert.func(fn, { where: WHERE, scope: this.name, method: 'onSet' });
+        (0, type_1.assertFunction)(fn, () => common_1.$opt.fn({ where: WHERE, scope: this.name, method: 'onSet' }));
         this._onSet = fn;
         return this;
     }
     onOta(fn) {
-        common_1.$assert.func(fn, { where: WHERE, scope: this.name, method: 'onOta' });
+        (0, type_1.assertFunction)(fn, () => common_1.$opt.fn({ where: WHERE, scope: this.name, method: 'onOta' }));
         this._onOta = fn;
         return this;
     }
     // endregion configure
     // region runtime
     getField(name) {
-        common_1.$assert.text(name, () => {
-            return { where: WHERE, scope: this.name, method: 'getField' };
-        });
+        (0, type_1.assertText)(name, () => common_1.$opt.fn({ where: WHERE, scope: this.name, method: 'getField' }));
         if (!this._fields.has(name)) {
-            throw common_1.$dev.developerError2(internal_1.FQN, 701, { message: 'Field could not found', where: WHERE, scope: this.name, method: 'getField', field: name });
+            throw new core_1.EnvironmentError('field.not.found', `Field[${name}] could not found`, { where: WHERE, scope: this.name, method: 'getField', field: name });
         }
         return this._fields.get(name);
     }
     hasField(name) {
-        common_1.$assert.text(name, () => {
-            return { where: WHERE, scope: this.name, method: 'hasField' };
-        });
+        (0, type_1.assertText)(name, () => common_1.$opt.fn({ where: WHERE, scope: this.name, method: 'hasField' }));
         return this._fields.has(name);
     }
     hasUse(name) {
-        common_1.$assert.text(name, () => {
-            return { where: WHERE, scope: this.name, method: 'hasUse' };
-        });
+        (0, type_1.assertText)(name, () => common_1.$opt.fn({ where: WHERE, scope: this.name, method: 'hasUse' }));
         return this._uses.has(name);
     }
     validUse(name) {
@@ -118,23 +117,38 @@ class EnvScopeImpl {
     print(asObject) {
         return this.core.print(asObject);
     }
-    get raw() {
-        if (this._raw !== undefined) {
-            return this._raw;
-        }
+    _readAgain() {
         this.read();
-        this._raw = {};
-        for (const [k, field] of this._fields.entries()) {
-            this._raw[k] = field.raw;
+        this._valueFull = {};
+        this._valueShort = {};
+        Array.from(this._fields.values())
+            .forEach(field => {
+            this._valueFull[field.full] = field.value;
+            this._valueShort[field.name] = field.value;
+        });
+    }
+    get valueFull() {
+        if (this._valueFull !== undefined) {
+            return this._valueFull;
+        }
+        this._readAgain();
+        return this._valueFull;
+    }
+    get valueShort() {
+        if (this._valueShort !== undefined) {
+            return this._valueShort;
         }
-        return this._raw;
+        this._readAgain();
+        return this._valueShort;
     }
     refresh() {
         this._run = false;
-        this._raw = undefined;
+        this._valueFull = undefined;
+        this._valueShort = undefined;
     }
     clear() {
-        this._raw = undefined;
+        this._valueFull = undefined;
+        this._valueShort = undefined;
     }
     get useList() {
         const rec = {};
@@ -145,9 +159,13 @@ class EnvScopeImpl {
     }
     fromOta(values) {
         this.refresh();
-        if (common_1.$is.bareObject(values)) {
+        if ((0, type_1.isObjectBare)(values)) {
             let changedAny = false;
-            for (const [name, value] of Object.entries(values)) {
+            for (const [full, value] of Object.entries(values)) {
+                let name = full.substring(this.prefix.length);
+                if (this.variation) {
+                    name = name.substring(this.variation.length);
+                }
                 const ins = this._fields.get(name);
                 if (ins) {
                     if (ins.fromOta(value)) {
@@ -156,7 +174,11 @@ class EnvScopeImpl {
                 }
             }
             if (changedAny && this._onOta) {
-                error_enveloper_1.errorEnveloper.handle(() => this._onOta(this), (e) => common_1.$dev.log({ message: 'OnOta Error', caused: e, where: WHERE, scope: this.name }, 'warn'));
+                error_enveloper_1.errorEnveloper.handle(() => this._onOta(this), (e) => logger.warn('OnOta Error', {
+                    caused: { name: e.name, message: e.message },
+                    where: WHERE,
+                    scope: this.name
+                }));
             }
         }
     }
@@ -176,11 +198,20 @@ class EnvScopeImpl {
         });
         if (changedAny && this._onChangeList) {
             this._onChangeList.forEach((fn, index) => {
-                error_enveloper_1.errorEnveloper.handle(() => fn(this), (e) => common_1.$dev.log({ message: 'OnChange Error', caused: e, where: WHERE, scope: this.name, index }, 'warn'));
+                error_enveloper_1.errorEnveloper.handle(() => fn(this), (e) => logger.warn('OnChange Error', {
+                    caused: { name: e.name, message: e.message },
+                    where: WHERE,
+                    scope: this.name,
+                    index
+                }));
             });
         }
         if (this._onSet) {
-            error_enveloper_1.errorEnveloper.handle(() => this._onSet(this), (e) => common_1.$dev.log({ message: 'OnSet error', caused: e, where: WHERE, scope: this.name }, 'warn'));
+            error_enveloper_1.errorEnveloper.handle(() => this._onSet(this), (e) => logger.warn('OnSet Error', {
+                caused: { name: e.name, message: e.message },
+                where: WHERE,
+                scope: this.name
+            }));
         }
     }
     $print() {
@@ -208,25 +239,61 @@ class EnvScopeImpl {
     get $secure() {
         return this;
     }
-    get begin() {
-        if (this._state === 'pending') {
-            this._state = 'started';
+    _getVariationName(variation) {
+        if (this.variation) {
+            throw new core_1.EnvironmentError('scope.already.varied', `Scope is already varied`, { value: this.name, where: WHERE, method: 'newVariation', variation });
         }
-        else {
-            common_1.$dev.log({ message: 'Unexpected begin of configure', state: this._state, scope: this.name, where: WHERE });
+        (0, type_1.assertText)(variation, () => common_1.$opt.fn({ where: WHERE, scope: this.name, method: 'newVariation', field: 'variation' }));
+        return `${this.name}#${variation}`;
+    }
+    newVariation(variation) {
+        const name = this._getVariationName(variation);
+        if (this.core.hasScope(name)) {
+            throw new core_1.EnvironmentError('scope.duplicated', `Scope[${name}] is duplicated`, { value: name, where: WHERE, method: 'newVariation' });
         }
-        return this;
+        return new EnvScopeImpl(this.core, name, this.prefix, variation);
+    }
+    getVariation(variation) {
+        const name = this._getVariationName(variation);
+        if (this.core.hasScope(name)) {
+            return this.core.getScope(name);
+        }
+        return new EnvScopeImpl(this.core, name, this.prefix, variation);
     }
-    get end() {
+    finish() {
+        if (this.variation) {
+            throw new core_1.EnvironmentError('varied.scope.does.not.support', `Scope[${this.name}] does not support finish operation`, { scope: this.name, where: WHERE, method: 'finish' });
+        }
         if (this._state === 'started') {
             this.read();
             this._state = 'completed';
         }
         else {
-            common_1.$dev.log({ message: 'Unexpected end of configure', state: this._state, scope: this.name, where: WHERE });
+            logger.warn('Unexpected end of configure', {
+                state: this._state,
+                scope: this.name,
+                where: WHERE
+            });
+        }
+        return this;
+    }
+    start() {
+        if (this.variation) {
+            throw new core_1.EnvironmentError('varied.scope.does.not.support', `Scope[${this.name}] does not support start operation`, { scope: this.name, where: WHERE, method: 'finish' });
+        }
+        if (this._state === 'pending') {
+            this._state = 'started';
+        }
+        else {
+            logger.warn('Unexpected begin of configure', {
+                state: this._state,
+                scope: this.name,
+                where: WHERE
+            });
         }
         return this;
     }
 }
 exports.EnvScopeImpl = EnvScopeImpl;
+const logger = common_1.$log.create(EnvScopeImpl);
 //# sourceMappingURL=env-scope.impl.js.map