jssm 5.79.0 → 5.79.3

package/dist/es6/jssm.d.ts

@@ -253,6 +253,7 @@ declare class Machine<mDT> {
     _property_keys: Set<string>;
     _default_properties: Map<string, any>;
     _state_properties: Map<string, any>;
+    _required_properties: Set<string>;
     _history: JssmHistory<mDT>;
     _history_length: number;
     constructor({ start_states, complete, transitions, machine_author, machine_comment, machine_contributor, machine_definition, machine_language, machine_license, machine_name, machine_version, state_declaration, property_definition, state_property, fsl_version, dot_preamble, arrange_declaration, arrange_start_declaration, arrange_end_declaration, theme, flow, graph_layout, instance_name, history, data }: JssmGenericConfig<mDT>);
@@ -312,6 +313,23 @@ declare class Machine<mDT> {
      *
      */
     prop(name: string): any;
+    /*********
+     *
+     *  Get the current value of a given property name.  If missing on the state
+     *  and without a global default, throw, unlike {@link prop}, which would
+     *  return `undefined` instead.
+     *
+     *  ```typescript
+     *
+     *  ```
+     *
+     *  @param name The relevant property name to look up
+     *
+     *  @returns The value behind the prop name.  Because functional props are
+     *  evaluated as getters, this can be anything.
+     *
+     */
+    strict_prop(name: string): any;
     /*********
      *
      *  Get the current value of every prop, as an object.  If no current definition

package/dist/es6/jssm.js

@@ -353,12 +353,14 @@ function compile_rule_handler(rule) {
     }
     // manually rehandled to make `undefined` as a property safe
     if (rule.key === 'property_definition') {
+        const ret = { agg_as: 'property_definition', val: { name: rule.name } };
         if (rule.hasOwnProperty('default_value')) {
-            return { agg_as: 'property_definition', val: { name: rule.name, default_value: rule.default_value } };
+            ret.val.default_value = rule.default_value;
         }
-        else {
-            return { agg_as: 'property_definition', val: { name: rule.name } };
+        if (rule.hasOwnProperty('required')) {
+            ret.val.required = rule.required;
         }
+        return ret;
     }
     // state properties are in here
     if (rule.key === 'state_declaration') {
@@ -503,7 +505,6 @@ function compile(tree) {
         sd.declarations.forEach(decl => {
             if (decl.key === 'state_property') {
                 const label = name_bind_prop_and_state(decl.name, sd.state);
-                console.log(`Bind ${sd.state}:${decl.name} as ${label}`);
                 if (result_cfg.state_property.findIndex(c => c.name === label) !== -1) {
                     throw new JssmError(undefined, `A state may only bind a property once (${sd.state} re-binds ${decl.name})`);
                 }
@@ -641,6 +642,7 @@ class Machine {
         this._property_keys = new Set();
         this._default_properties = new Map();
         this._state_properties = new Map();
+        this._required_properties = new Set();
         this._history_length = history || 0;
         this._history = new circular_buffer(this._history_length);
         if (state_declaration) {
@@ -744,6 +746,9 @@ class Machine {
                 if (pr.hasOwnProperty('default_value')) {
                     this._default_properties.set(pr.name, pr.default_value);
                 }
+                if (pr.hasOwnProperty('required') && (pr.required === true)) {
+                    this._required_properties.add(pr.name);
+                }
             });
         }
         if (Array.isArray(state_property)) {
@@ -751,6 +756,32 @@ class Machine {
                 this._state_properties.set(sp.name, sp.default_value);
             });
         }
+        // done building, do checks
+        this._state_properties.forEach((_value, key) => {
+            const inside = JSON.parse(key);
+            if (Array.isArray(inside)) {
+                const j_property = inside[0];
+                if (typeof j_property === 'string') {
+                    const j_state = inside[1];
+                    if (typeof j_state === 'string') {
+                        if (!(this.known_prop(j_property))) {
+                            throw new JssmError(this, `State "${j_state}" has property "${j_property}" which is not globally declared`);
+                        }
+                    }
+                }
+            }
+        });
+        this._required_properties.forEach(dp_key => {
+            if (this._default_properties.has(dp_key)) {
+                throw new JssmError(this, `The property "${dp_key}" is required, but also has a default; these conflict`);
+            }
+            this.states().forEach(s => {
+                const bound_name = name_bind_prop_and_state(dp_key, s);
+                if (!(this._state_properties.has(bound_name))) {
+                    throw new JssmError(this, `State "${s}" is missing required property "${dp_key}"`);
+                }
+            });
+        });
     }
     /********
      *
@@ -845,6 +876,35 @@ class Machine {
         }
     }
     // NEEDS_DOCS
+    /*********
+     *
+     *  Get the current value of a given property name.  If missing on the state
+     *  and without a global default, throw, unlike {@link prop}, which would
+     *  return `undefined` instead.
+     *
+     *  ```typescript
+     *
+     *  ```
+     *
+     *  @param name The relevant property name to look up
+     *
+     *  @returns The value behind the prop name.  Because functional props are
+     *  evaluated as getters, this can be anything.
+     *
+     */
+    strict_prop(name) {
+        const bound_name = name_bind_prop_and_state(name, this.state());
+        if (this._state_properties.has(bound_name)) {
+            return this._state_properties.get(bound_name);
+        }
+        else if (this._default_properties.has(name)) {
+            return this._default_properties.get(name);
+        }
+        else {
+            throw new JssmError(this, `Strictly requested a prop '${name}' which doesn't exist on current state '${this.state()}' and has no default`);
+        }
+    }
+    // NEEDS_DOCS
     // COMEBACK add prop_map, sparse_props and strict_props to doc text when implemented
     /*********
      *

package/dist/es6/jssm_types.d.ts

@@ -38,6 +38,7 @@ declare type JssmSerialization<DataType> = {
 declare type JssmPropertyDefinition = {
     name: string;
     default_value?: any;
+    required?: boolean;
 };
 declare type JssmTransitionPermitter<DataType> = (OldState: StateType, NewState: StateType, OldData: DataType, NewData: DataType) => boolean;
 declare type JssmTransitionPermitterMaybeArray<DataType> = JssmTransitionPermitter<DataType> | Array<JssmTransitionPermitter<DataType>>;
@@ -173,6 +174,7 @@ declare type JssmCompileSeStart<DataType> = {
     name?: string;
     state?: string;
     default_value?: any;
+    required?: boolean;
 };
 declare type JssmParseTree = Array<JssmCompileSeStart<StateType>>;
 declare type JssmParseFunctionType = (string: any) => JssmParseTree;

package/dist/es6/version.js

@@ -1,2 +1,2 @@
-const version = "5.79.0";
+const version = "5.79.3";
 export { version };