fix: Prefix tag trigger with v as GitVersion expects (#387)

* Get rid of unneccessary from_sketchup check everytime

* Correct the hard edge types

.circleci/config.yml

@@ -1,162 +0,0 @@
-version: 2.1
-
-orbs:
-  # Using windows for builds
-  win: circleci/windows@2.4.0
-  # Upload artifacts to s3
-  aws-s3: circleci/aws-s3@2.0.0
-
-jobs:
-  build-ui:
-    docker:
-      - image: "circleci/node:16"
-    steps:
-      - checkout
-      - run:
-          command: "npm install"
-          working_directory: "ui"
-      - run:
-          command: "npm run build"
-          working_directory: "ui"
-      - persist_to_workspace:
-          root: ./
-          paths:
-            - speckle_connector/vue_ui
-
-  build-connector: # Reusable job for basic connectors
-    executor:
-      name: win/default # comes with python 3.7.3
-      shell: cmd.exe
-    parameters:
-      slug:
-        type: string
-        default: ""
-    steps:
-      - checkout
-      - attach_workspace:
-          at: ./
-      - run:
-          name: Create Innosetup signing cert
-          shell: powershell.exe
-          command: |
-            echo $env:PFX_B64 > "speckle-sharp-ci-tools\SignTool\AEC Systems Ltd.txt"
-            certutil -decode "speckle-sharp-ci-tools\SignTool\AEC Systems Ltd.txt" "speckle-sharp-ci-tools\SignTool\AEC Systems Ltd.pfx"
-      - run:
-          name: Set Environment Variable
-          shell: powershell.exe
-          command: |
-            $tag = if([string]::IsNullOrEmpty($env:CIRCLE_TAG)) { "2.0.999" } else { $env:CIRCLE_TAG }
-            $semver = if($tag.Contains('/')) {$tag.Split("/")[0] } else { $tag }
-            $ver = if($semver.Contains('-')) {$semver.Split("-")[0] } else { $semver }
-            $version = "$($ver).$($env:WORKFLOW_NUM)"
-            python patch_version.py $semver
-          environment:
-            WORKFLOW_NUM: << pipeline.number >>
-      - run:
-          name: Build Installer
-          command: speckle-sharp-ci-tools\InnoSetup\ISCC.exe speckle-sharp-ci-tools\sketchup.iss /Sbyparam=$p
-          shell: cmd.exe #does not work in powershell
-
-      #- run:
-      #    name: Patch
-      #    shell: powershell.exe
-      #    command:
-      #      | # If no tag, use 0.0.0.1 and don't make any YML (for testing only!)
-      #      $tag = if([string]::IsNullOrEmpty($env:CIRCLE_TAG)) { "0.0.0" } else { $env:CIRCLE_TAG }
-      #      $semver = if($tag.Contains('/')) {$tag.Split("/")[1] } else { $tag }
-      #      $ver = if($semver.Contains('-')) {$semver.Split("-")[0] } else { $semver }
-      #      $channel = if($semver.Contains('-')) {$semver.Split("-")[1] } else { "latest" }
-      #      $version = "$($ver).$($env:CIRCLE_BUILD_NUM)"
-      #      New-Item -Force "speckle-sharp-ci-tools/Installers/sketchup/$channel.yml" -ItemType File -Value "version: $semver"
-      #      echo $version
-      #      python patch_version.py $semver
-      #      speckle-sharp-ci-tools\InnoSetup\ISCC.exe speckle-sharp-ci-tools\sketchup.iss
-      - persist_to_workspace:
-          root: ./
-          paths:
-            - speckle-sharp-ci-tools/Installers
-
-  get-ci-tools: # Clones our ci tools and persists them to the workspace
-    docker:
-      - image: cimg/base:2021.01
-    steps:
-      - add_ssh_keys:
-          fingerprints:
-            - "03:2e:ee:4f:14:67:2b:88:32:e8:cc:f0:cb:df:92:29"
-      - run:
-          name: I know Github as a host
-          command: |
-            mkdir ~/.ssh
-            ssh-keyscan github.com >> ~/.ssh/known_hosts
-      - run:
-          name: Clone
-          command: git clone git@github.com:specklesystems/speckle-sharp-ci-tools.git speckle-sharp-ci-tools
-      - persist_to_workspace:
-          root: ./
-          paths:
-            - speckle-sharp-ci-tools
-      - persist_to_workspace:
-          root: ./
-          paths:
-            - speckle-sharp-ci-tools
-  deploy-manager2:
-    docker:
-      - image: mcr.microsoft.com/dotnet/sdk:6.0
-    parameters:
-      slug:
-        type: string
-      os:
-        type: string
-      extension:
-        type: string
-    steps:
-      - checkout
-      - attach_workspace:
-          at: ./
-      - run:
-          name: Install Manager Feed CLI
-          command: dotnet tool install --global Speckle.Manager.Feed
-      - run:
-          name: Upload new version
-          command: |
-            TAG=$(if [ "${CIRCLE_TAG}" ]; then echo $CIRCLE_TAG; else echo "0.0.0"; fi;)
-            SEMVER=$(echo "$TAG" | sed -e 's/\/[a-zA-Z-]*//')
-            /root/.dotnet/tools/Speckle.Manager.Feed deploy -s << parameters.slug >> -v ${SEMVER} -u https://releases.speckle.dev/installers/<< parameters.slug >>/<< parameters.slug >>-${SEMVER}.<< parameters.extension >> -o << parameters.os >> -f speckle-sharp-ci-tools/Installers/<< parameters.slug >>/<< parameters.slug >>-${SEMVER}.<< parameters.extension >>
-
-workflows:
-  build-and-deploy:
-    jobs:
-      - get-ci-tools:
-          filters:
-            tags:
-              only: /.*/
-
-      - build-ui:
-          filters:
-            tags:
-              only: /.*/
-
-      - build-connector:
-          slug: sketchup
-          requires:
-            - get-ci-tools
-            - build-ui
-          filters:
-            tags:
-              only: /.*/
-          context: innosetup
-
-      - deploy-manager2:
-          context: do-spaces-speckle-releases
-          slug: sketchup
-          os: Win
-          extension: exe
-          requires:
-            - get-ci-tools
-            - build-ui
-            - build-connector
-          filters:
-            tags:
-              only: /([0-9]+)\.([0-9]+)\.([0-9]+)(?:-\w+)?$/
-            branches:
-              ignore: /.*/ # For testing only! /ci\/.*/

.github/workflows/build.yml

@@ -0,0 +1,59 @@
+# This workflow will install Python dependencies, run tests and lint with a single version of Python
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Build
+
+on:
+  pull_request:
+  workflow_call:
+    outputs:
+      semver:
+        description: "The computed version number for this run"
+        value: ${{ jobs.build.outputs.semver }}
+      file_version:
+        description: "The assembly info version for this run"
+        value: ${{ jobs.build.outputs.file_version }}
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    outputs:
+      semver: ${{ steps.set-version.outputs.semver }}
+      file_version: ${{ steps.set-info-version.outputs.file-version }}
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Set up Python 3.10
+        uses: actions/setup-python@v3
+        with:
+          python-version: "3.10"
+
+      - name: Install GitVersion
+        uses: gittools/actions/gitversion/setup@v3.0.0
+        with:
+          versionSpec: "5.x"
+
+      - name: Determine Version
+        id: gitversion
+        uses: gittools/actions/gitversion/execute@v3.0.0
+
+      - name: Set connector version
+        run: |
+          python patch_version.py ${{steps.gitversion.outputs.semVer}}
+
+      - uses: montudor/action-zip@v1
+        with:
+          args: zip -q -r sketchup.zip vendor speckle_connector_3/ speckle_connector_3.rb
+      - name: ⬆️ Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: output-${{steps.gitversion.outputs.semVer}}
+          path: sketchup.zip
+          compression-level: 0 # no compression
+      - id: set-version
+        name: Set version to output
+        run: echo "semver=${{steps.gitversion.outputs.semVer}}" >> "$GITHUB_OUTPUT" # version will be retrieved from tag?
+      - id: set-info-version
+        name: Set version to output
+        run: echo "file-version=${{steps.gitversion.outputs.AssemblySemVer}}" >> "$GITHUB_OUTPUT" # version will be retrieved from tag?

.github/workflows/deploy.yml

@@ -0,0 +1,33 @@
+# This workflow will install Python dependencies, run tests and lint with a single version of Python
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-python
+
+name: Build and deploy
+
+on:
+  push:
+    branches: ["dui3/alpha", "deploy/*"] # Continuous delivery on every long-lived branch
+    tags: ["v3.*"] # Manual delivery on every 3.x tag
+
+jobs:
+  build:
+    uses: ./.github/workflows/build.yml
+
+  deploy-installers:
+    runs-on: ubuntu-latest
+    needs: build
+    env:
+      IS_TAG_BUILD: ${{ github.ref_type == 'tag' }}
+    steps:
+      - name: 🔫 Trigger Build Installers
+        uses: ALEEF02/workflow-dispatch@v3.0.0
+        with:
+          workflow: Build Sketchup
+          repo: specklesystems/connector-installers
+          token: ${{ secrets.CONNECTORS_GH_TOKEN }}
+          inputs: '{ "run_id": "${{ github.run_id }}", "semver": "${{ needs.build.outputs.semver }}", "file_version": "${{ needs.build.outputs.file_version }}", "public_release": ${{ env.IS_TAG_BUILD }} }'
+          ref: main
+          wait-for-completion: true
+          wait-for-completion-interval: 10s
+          wait-for-completion-timeout: 10m
+          display-workflow-run-url: true
+          display-workflow-run-url-interval: 10s

.gitignore

@@ -10,8 +10,8 @@
 settings.json
 
 # vue app build dist folder
-speckle_connector/vue_ui
-speckle_connector/html
+speckle_connector_3/vue_ui
+speckle_connector_3/html
 
 # speckle-sharp-ci-tools
 /speckle-sharp-ci-tools

.rubocop.yml

@@ -18,7 +18,7 @@ AllCops:
     - '_tools/su_attributes/**/*.rb'
     - '_sqlite3/**/*.rb'
     - 'ui/**/*'
-    - 'speckle_connector/src/ext/**/*.rb'
+    - 'speckle_connector_3/src/ext/**/*.rb'
     - 'vendor/bundle/**/*'
     - 'tests/**/*.rb'
   SketchUp:

.solargraph.yml

@@ -1,6 +1,6 @@
 require_paths:
 - "C:/Program Files/SketchUp/SketchUp 2021/Tools"
-- speckle_connector
+- speckle_connector_3
 
 require:
 - sketchup-api-stubs

Gemfile

@@ -24,6 +24,8 @@ group :development do
   gem 'rubycritic', '~> 4.3', '>= 4.3.3', require: false
   # Auto completions for SketchUp API.
   gem 'sketchup-api-stubs'
+  # Runtime dependency of skippy for Ruby 3.2. Have it!
+  gem 'sorted_set', '~> 1.0'
   # Aid with common SketchUp extension tasks.
-  gem 'skippy', '~> 0.4.1.a'
+  gem 'skippy', '~> 0.5.2.a'
 end

Gemfile.lock

@@ -1,7 +1,7 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    addressable (2.8.1)
+    addressable (2.8.4)
       public_suffix (>= 2.0.2, < 6.0)
     ast (2.4.2)
     axiom-types (0.1.1)
@@ -26,7 +26,7 @@ GEM
       path_expander (~> 1.0)
       ruby_parser (~> 3.1, > 3.1.0)
       sexp_processor (~> 4.8)
-    git (1.12.0)
+    git (1.19.1)
       addressable (~> 2.8)
       rchardet (~> 1.8)
     ice_nine (0.11.2)
@@ -48,10 +48,10 @@ GEM
     pry (0.14.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
-    psych (3.3.4)
-    public_suffix (5.0.0)
+    public_suffix (5.0.1)
     rainbow (3.1.1)
     rake (13.0.6)
+    rbtree (0.4.6)
     rchardet (1.8.0)
     reek (6.1.1)
       kwalify (~> 0.7.0)
@@ -90,6 +90,7 @@ GEM
       simplecov (>= 0.17.0)
       tty-which (~> 0.4.0)
       virtus (~> 1.0)
+    set (1.1.0)
     sexp_processor (4.16.1)
     simplecov (0.21.2)
       docile (~> 1.1)
@@ -98,11 +99,15 @@ GEM
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
     sketchup-api-stubs (0.7.8)
-    skippy (0.4.3.a)
+    skippy (0.5.2.a)
       git (~> 1.3)
       naturally (~> 2.1)
-      thor (~> 0.19)
-    thor (0.20.3)
+      sorted_set (~> 1.0)
+      thor (>= 0.19, < 2.0)
+    sorted_set (1.0.3)
+      rbtree
+      set (~> 1.0)
+    thor (1.3.1)
     thread_safe (0.3.6)
     tty-which (0.4.2)
     unicode-display_width (1.8.0)
@@ -113,6 +118,7 @@ GEM
       equalizer (~> 0.0, >= 0.0.9)
 
 PLATFORMS
+  x64-mingw-ucrt
   x64-mingw32
   x64-unknown
   x86_64-linux
@@ -128,7 +134,8 @@ DEPENDENCIES
   rubocop-sketchup
   rubycritic (~> 4.3, >= 4.3.3)
   sketchup-api-stubs
-  skippy (~> 0.4.1.a)
+  skippy (~> 0.5.2.a)
+  sorted_set (~> 1.0)
 
 BUNDLED WITH
    2.3.25

GitVersion.yml

@@ -0,0 +1,18 @@
+next-version: 3.0.0
+mode: ContinuousDeployment
+assembly-informational-format: "{Major}.{Minor}.{Patch}-{PreReleaseTag}"
+branches:
+  main:
+    regex: ^main$
+    tag: rc
+  develop:
+    regex: ^development$
+    tag: dev
+  pull-request:
+    tag: pr
+  beta:
+    regex: ^dui3/alpha$
+    tag: beta
+    source-branches:
+      - develop
+      - main

README.md

@@ -49,9 +49,9 @@ This repo is split into three parts:
 ### 1. **Speckle Connector extension** 
    
    Includes the `ruby` source files to run extension on SketchUp environment. SketchUp Extensions are composed of
-   a **.rb** file as entry and **folder** that .rb file refers to. In our case entry file is `speckle_connector.rb`
+   a **.rb** file as entry and **folder** that .rb file refers to. In our case entry file is `speckle_connector_3.rb`
    that responsible to register Speckle Connector extension to SketchUp and also it shows address to where extension
-   will start to read extension. Source folder is `speckle_connector`.
+   will start to read extension. Source folder is `speckle_connector_3`.
 
 ### 2. **User Interface**
 
@@ -64,7 +64,7 @@ This repo is split into three parts:
    we use extensions as native part of the source `ruby` code. 
 
    After building `sqlite3.sln` file, compiled `sqlite3.so` (for Windows) and `sqlite3.bundle` (for OSX) dynamic library files are created
-   by solution to place them into source code into `speckle_connector/src/ext`. Building this project should be only
+   by solution to place them into source code into `speckle_connector_3/src/ext`. Building this project should be only
    happen when SketchUp starts to support newer Ruby versions (currently it is `2.7`).
 
 ## Contribution Guide
@@ -117,7 +117,7 @@ If you will use VS Code, make sure you've installed the Ruby extension for VS Co
 
 ### Loading the Speckle Connector Plugin
 
-1. Find already prepared `speckle_connector_loader.rb` file on the `_tools`
+1. Find already prepared `speckle_connector_3_loader.rb` file on the `_tools`
 folder.
 2. Copy this Ruby file into your SketchUp Plugins directory. You will likely find this at:
     `C:\Users\{YOU}\AppData\Roaming\SketchUp\SketchUp 20XX\SketchUp\Plugins`

Rakefile

@@ -32,12 +32,12 @@ end
 
 # Glob pattern to match source files. Defaults to FileList['.'].
 ruby_critic_paths = FileList[
-  'speckle_connector/**/*.rb',
-  'speckle_connector.rb',
+  'speckle_connector_3/**/*.rb',
+  'speckle_connector_3.rb',
   'tests/**/*.rb'] -
                     FileList[
                     '_tools/**/*.rb',
-                    'speckle_connector/src/ext/**/*.rb',
+                    'speckle_connector_3/src/ext/**/*.rb',
                     ]
 
 # for local

_tools/debugger/skippy_exec_2024.rb

@@ -0,0 +1,15 @@
+# This is for automated pre-debugger configuration.
+# We run skippy first, then activate debugger.
+# The purpose of this file to wait till skp is live
+
+# To establish a configuration
+#  1. Create 'Run External Tool' before lunch step
+#  2. Program -> C:\Ruby32-x64\bin\ruby.exe or whatever
+#  3. Arguments -> C:\Users\KORAL\Documents\Git\Speckle\speckle-sketchup\_tools\debugger\bundle_exec_2024.rb or whatever
+#  4. Working directory -> C:\Users\KORAL\Documents\Git\Speckle\speckle-sketchup or whatever
+
+# Add a delay of 10 seconds, it is arbitrary, do not hesitate to change for what works best for you
+sleep(10)
+
+# Execute the original command
+exec('bundle exec skippy sketchup:debug 2024')

_tools/jf_RubyPanel/rubytoolbar.rb

@@ -24,7 +24,7 @@ module JF_RubyToolbar
   def self.load_toolbar
     @last_dir = "#{$LOAD_PATH[0]}/"
     @last_dir = @last_dir.gsub('/', '\\\\\\\\')
-    @last_dir = File.join($JF_RUBYTOOLBAR, 'speckle_connector')
+    @last_dir = File.join($JF_RUBYTOOLBAR, 'speckle_connector_3')
     curdir = File.dirname __FILE__
 
     # create toolbar

_tools/speckle_connector_3_loader.rb

@@ -10,7 +10,7 @@
 # Create a link to Plugins folder with this command
 
 # rubocop:disable Layout/LineLength
-# New-Item -ItemType SymbolicLink -Path '~\AppData\Roaming\SketchUp\SketchUp 2022\SketchUp\Plugins\speckle_connector_loader.rb' -Target ~\Git\Speckle\speckle-sketchup\_tools\speckle_connector_loader.rb
+# New-Item -ItemType SymbolicLink -Path '~\AppData\Roaming\SketchUp\SketchUp 2022\SketchUp\Plugins\speckle_connector_3_loader.rb' -Target ~\Git\Speckle\speckle-sketchup\_tools\speckle_connector_3_loader.rb
 # rubocop:enable Layout/LineLength
 
 SKETCHUP_CONSOLE.show # if you want to show Ruby console on startup
@@ -32,7 +32,7 @@ $LOAD_PATH << File.join(speckle_path, '_tools')
 $JF_RUBYTOOLBAR = speckle_path
 # rubocop:enable Style/GlobalVars
 
-files = %w[speckle_connector jf_RubyPanel su_attributes]
+files = %w[speckle_connector_3 jf_RubyPanel su_attributes]
 
 files.each do |ruby_file|
   puts "Loading #{ruby_file}"

patch_version.py

@@ -4,7 +4,7 @@ import sys
 
 def patch_connector(tag):
     """Patches the connector version within the connector file"""
-    rb_file = "speckle_connector.rb"
+    rb_file = "speckle_connector_3.rb"
 
     with open(rb_file, "r") as file:
         lines = file.readlines()
@@ -15,6 +15,12 @@ def patch_connector(tag):
                 print(f"Patched connector version number in {rb_file}")
                 break
 
+        for (index, line) in enumerate(lines):
+            if 'DEV_MODE = ' in line:
+                lines[index] = f'    DEV_MODE = false\n'
+                print(f"Patched dev mode to false in {rb_file}")
+                break
+
         with open(rb_file, "w") as file:
             file.writelines(lines)
 
@@ -45,7 +51,7 @@ def main():
 
     print(f"Patching version: {tag}")
     patch_connector(tag)
-    patch_installer(tag)
+    # patch_installer(tag)
 
 
 if __name__ == "__main__":

speckle_connector/src/actions/events/entities_event_action.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'event_action'
-require_relative '../../sketchup_model/utils/face_utils'
-require_relative '../../constants/dict_constants'
-
-module SpeckleConnector
-  module Actions
-    module Events
-      # Event actions related to entities.
-      class EntitiesEventAction < EventAction
-        # Event action when element added.
-        class OnElementAdded
-          # @param state [States::State] the current state of the SpeckleConnector Application
-          def self.update_state(state, event_data)
-            modified_entities = event_data.to_a.collect { |e| e[1] }
-            # do not copy speckle base object specific attributes, because they are entity specific
-            modified_entities.each { |entity| entity.delete_attribute(SPECKLE_BASE_OBJECT) }
-            state
-          end
-        end
-
-        # Event action when element modified.
-        class OnElementModified
-          # @param state [States::State] the current state of the SpeckleConnector Application
-          def self.update_state(state, event_data)
-            speckle_state = state.speckle_state
-            modified_entity = event_data[0][1]
-            if modified_entity.is_a?(Sketchup::Face)
-              path = state.sketchup_state.sketchup_model.active_path
-              modified_faces = SketchupModel::Utils::FaceUtils.near_faces(modified_entity.edges)
-              path_objects = path.nil? ? [] : path + path.collect(&:definition)
-              parent_ids = path_objects.collect(&:persistent_id)
-              ids_to_invalidate = modified_faces.collect(&:persistent_id) + parent_ids
-              entities_to_invalidate = speckle_entities_to_invalidate(speckle_state, ids_to_invalidate)
-              new_speckle_state = invalidate_speckle_entities(speckle_state, entities_to_invalidate)
-              # This is the place we can send information to UI for diffing check
-              diffing = state.user_state.preferences[:user][:diffing]
-              new_speckle_state = new_speckle_state.with_invalid_streams_queue if diffing
-              return state.with_speckle_state(new_speckle_state)
-            end
-
-            state
-          end
-
-          # @param speckle_state [States::SpeckleState] the current state of the Speckle
-          def self.speckle_entities_to_invalidate(speckle_state, ids)
-            speckle_state.speckle_entities.to_h.select { |id, _| ids.include?(id) }
-          end
-
-          # @param speckle_state [States::SpeckleState] the current state of the Speckle
-          def self.invalidate_speckle_entities(speckle_state, entities_to_invalidate)
-            speckle_entities = speckle_state.speckle_entities
-            entities_to_invalidate.each do |id, speckle_entity|
-              edited_speckle_entity = speckle_entity.with_invalid
-              speckle_entities = speckle_entities.put(id, edited_speckle_entity)
-            end
-            speckle_state.with_speckle_entities(speckle_entities)
-          end
-        end
-
-        # Event action when element removed.
-        class OnElementRemoved
-          # @param state [States::State] the current state of the SpeckleConnector Application
-          def self.update_state(state, _event_data)
-            # TODO: Do state updates when element removed
-            state
-          end
-        end
-
-        # Handlers that are used to handle specific events
-        ACTIONS = {
-          onElementRemoved: OnElementRemoved,
-          onElementAdded: OnElementAdded,
-          onElementModified: OnElementModified
-        }.freeze
-
-        def self.actions
-          ACTIONS
-        end
-      end
-    end
-  end
-end

speckle_connector/src/actions/one_click_send.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'action'
-require_relative '../accounts/accounts'
-require_relative '../actions/create_stream'
-require_relative '../actions/queue_send'
-require_relative '../convertors/to_speckle'
-
-module SpeckleConnector
-  module Actions
-    # Sends to speckle.
-    class OneClickSend < Action
-      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
-      # @return [States::State] the new updated state object
-      def self.update_state(state)
-        puts 'send to speckle'
-        default_account = Accounts.default_account
-        if default_account.nil?
-          puts 'No local account found. Please refer to speckle.guide for more information.'
-          return state
-        end
-        sketchup_model = state.sketchup_state.sketchup_model
-        to_convert = sketchup_model.selection.count > 0 ? sketchup_model.selection : sketchup_model.entities
-        first_saved_stream = first_saved_stream(sketchup_model)
-        action = if first_saved_stream.nil?
-                   Actions::CreateStream.new
-                 else
-                   Actions::QueueSend.new(first_saved_stream, convert_to_speckle(sketchup_model, to_convert))
-                 end
-
-        action.update_state(state)
-      end
-
-      def self.first_saved_stream(model)
-        (saved_streams = model.attribute_dictionary('speckle', true)['streams']) or []
-        saved_streams.nil? || saved_streams.empty? ? nil : saved_streams[0]
-      end
-
-      def self.convert_to_speckle(sketchup_model, to_convert)
-        converter = Converters::ToSpeckle.new(sketchup_model)
-        to_convert.map { |entity| converter.convert(entity) }
-      end
-    end
-  end
-end

speckle_connector/src/commands/command.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module SpeckleConnector
-  module Commands
-    # Base command schema to wrap common operations for all commands.
-    class Command
-      # @return [App::SpeckleConnectorApp] the main app object
-      attr_reader :app
-
-      # @return [Ui::View] view object holds dialog and it's state
-      attr_reader :view
-
-      # @@param app [App::SpeckleConnectorApp] the main app object
-      def initialize(app)
-        @app = app
-        @view = app.ui_controller.user_interfaces[Ui::SPECKLE_UI_ID]
-      end
-
-      def run(*parameters)
-        # Run here common operations that same for each command.
-        with_observers_disabled do
-          _run(*parameters)
-        end
-      end
-
-      private
-
-      def with_observers_disabled(&block)
-        observer_handler = @app.observer_handler
-        if observer_handler
-          observer_handler.with_observers_disabled(&block)
-        else
-          block.call
-        end
-      end
-
-      def _run(*_parameters)
-        raise NotImplementedError, 'Implement in subclass'
-      end
-    end
-  end
-end

speckle_connector/src/commands/dialog_ready.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'command'
-
-module SpeckleConnector
-  module Commands
-    # Run this command when the UI is ready to get data
-    class DialogReady < Command
-      # Update the selected user interface
-      def _run(_data)
-        view.update_view(app.state)
-      end
-    end
-  end
-end

speckle_connector/src/commands/speckle_menu_commands.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'menu_command_handler'
-require_relative 'action_command'
-require_relative 'initialize_speckle'
-require_relative '../actions/one_click_send'
-
-module SpeckleConnector
-  module Commands
-    # Speckle menu commands that adds them to Sketchup menu and toolbar.
-    class SpeckleMenuCommands
-      CMD_INITIALIZE_SPECKLE = :initialize_speckle
-      CMD_SEND_TO_SPECKLE = :send_to_speckle
-      CMD_RECEIVE_FROM_SPECKLE = :receive_from_speckle
-
-      # Add initial set of commands to Speckle application object and to Sketchup menu and toolbar
-      # @param app [App::SpeckleConnectorApp] the application object
-      def self.add_initial_commands!(app)
-        commands = app.menu_commands
-        ui_controller = app.ui_controller
-        sketchup_ui = ui_controller.sketchup_ui
-        speckle_menu = sketchup_ui.speckle_menu
-        speckle_toolbar = sketchup_ui.speckle_toolbar
-
-        commands[CMD_INITIALIZE_SPECKLE] = initialize_speckle_command(app)
-        commands.add_to_menu!(CMD_INITIALIZE_SPECKLE, speckle_menu)
-        commands.add_to_toolbar!(CMD_INITIALIZE_SPECKLE, speckle_toolbar)
-
-        # commands[CMD_SEND_TO_SPECKLE] = send_command(app)
-        # commands.add_to_menu!(CMD_SEND_TO_SPECKLE, speckle_menu)
-        # commands.add_to_toolbar!(CMD_SEND_TO_SPECKLE, speckle_toolbar)
-      end
-
-      def self.initialize_speckle_command(app)
-        cmd = MenuCommandHandler.sketchup_command(
-          InitializeSpeckle.new(app), 'Initialize Speckle'
-        )
-        cmd.tooltip = 'Launch Connector'
-        cmd.status_bar_text = 'Opens the Speckle Connector window'
-        cmd.small_icon  = '../../img/s2logo.png'
-        cmd.large_icon  = '../../img/s2logo.png'
-        cmd
-      end
-
-      def self.send_command(app)
-        cmd = MenuCommandHandler.sketchup_command(
-          ActionCommand.new(app, Actions::OneClickSend), 'Send to Speckle'
-        )
-        cmd.tooltip = 'Send to Speckle'
-        cmd.status_bar_text = 'Send to Speckle'
-        cmd.small_icon = '../../img/Sender.png'
-        cmd.large_icon = '../../img/Sender.png'
-        cmd.set_validation_proc { MenuCommandHandler.speckle_started(app) }
-        cmd
-      end
-    end
-  end
-end

speckle_connector/src/constants/observer_constants.rb

@@ -1,7 +0,0 @@
-# frozen_string_literal: true
-
-module SpeckleConnector
-  APP_OBSERVER = 'SpeckleConnector::Observers::AppObserver'
-  ENTITIES_OBSERVER = 'SpeckleConnector::Observers::EntitiesObserver'
-  MODEL_OBSERVER = 'SpeckleConnector::Observers::ModelObserver'
-end

speckle_connector/src/constants/type_constants.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module SpeckleConnector
-  BASE_OBJECT = 'Base'
-
-  OBJECTS_BUILTELEMENTS_VIEW3D = 'Objects.BuiltElements.View:Objects.BuiltElements.View3D'
-
-  OBJECTS_GEOMETRY_LINE = 'Objects.Geometry.Line'
-  OBJECTS_GEOMETRY_POLYLINE = 'Objects.Geometry.Polyline'
-  OBJECTS_GEOMETRY_MESH = 'Objects.Geometry.Mesh'
-  OBJECTS_GEOMETRY_BREP = 'Objects.Geometry.Brep'
-
-  OBJECTS_OTHER_BLOCKINSTANCE = 'Objects.Other.BlockInstance'
-  OBJECTS_OTHER_BLOCKINSTANCE_FULL = 'Objects.Other.Instance:Objects.Other.BlockInstance'
-  OBJECTS_OTHER_INSTANCE = 'Objects.Other.Instance:Objects.Other.Instance'
-  OBJECTS_OTHER_REVIT_REVITINSTANCE = 'Objects.Other.Revit.RevitInstance'
-  OBJECTS_OTHER_BLOCKDEFINITION = 'Objects.Other.BlockDefinition'
-  OBJECTS_OTHER_RENDERMATERIAL = 'Objects.Other.RenderMaterial'
-end

speckle_connector/src/convertors/to_speckle.rb

@@ -1,230 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'converter'
-require_relative 'base_object_serializer'
-require_relative '../speckle_objects/base'
-require_relative '../speckle_objects/geometry/line'
-require_relative '../speckle_objects/geometry/length'
-require_relative '../speckle_objects/geometry/mesh'
-require_relative '../speckle_objects/other/block_instance'
-require_relative '../speckle_objects/other/block_definition'
-require_relative '../speckle_objects/other/rendering_options'
-require_relative '../speckle_objects/built_elements/view3d'
-require_relative '../constants/path_constants'
-
-module SpeckleConnector
-  module Converters
-    # Converts sketchup entities to speckle objects.
-    class ToSpeckle < Converter
-      # Convert selected objects by putting them into related array that grouped by layer.
-      # @return [Hash{Symbol=>Array}] layers -which only have objects- to hold it's objects under the base object.
-      def convert_selection_to_base(preferences)
-        layers = add_all_layers
-        state = speckle_state
-        sketchup_model.selection.each do |entity|
-          new_speckle_state, converted_object_with_entity = convert(entity, preferences, state)
-          state = new_speckle_state
-          layer_name = entity_layer_path(entity)
-          layers[layer_name].push(converted_object_with_entity)
-        end
-        # send only+ layers that have any object
-        base_object_properties = layers.reject { |_layer_name, objects| objects.empty? }
-        add_views(base_object_properties) if sketchup_model.pages.any?
-        return state, SpeckleObjects::Base.with_detached_layers(base_object_properties)
-      end
-
-      # Add views from pages.
-      # @param base_object_properties [Hash] dynamically attached base object properties.
-      def add_views(base_object_properties)
-        views = []
-        sketchup_model.pages.each do |page|
-          cam = page.camera
-          origin = get_camera_origin(cam)
-          target = get_camera_target(cam)
-          direction = get_camera_direction(cam)
-          update_properties = get_scene_update_properties(page)
-          rendering_options = SpeckleObjects::Others::RenderingOptions.to_speckle(page.rendering_options)
-          view = SpeckleObjects::BuiltElements::View3d.new(
-            page.name, origin, target, direction, SpeckleObjects::Geometry::Vector.new(0, 0, 1, @units),
-            cam.perspective?, cam.fov, @units, page.name, update_properties, rendering_options
-          )
-          views.append(view)
-        end
-        base_object_properties['@Named Views'] = views
-      end
-
-      # Get scene properties
-      # @param page [Sketchup::Page] page on sketchup.
-      def get_scene_update_properties(page)
-        {
-          use_axes: page.use_axes?,
-          use_camera: page.use_camera?,
-          use_hidden_geometry: page.use_hidden_geometry?,
-          use_hidden_layers: page.use_hidden_layers?,
-          use_hidden_objects: page.use_hidden_objects?,
-          use_rendering_options: page.use_rendering_options?,
-          use_section_planes: page.use_section_planes?,
-          use_shadow_info: page.use_shadow_info?,
-          use_style: page.use_style?
-        }
-      end
-
-      # Serialized and traversed information to send batches.
-      # @param base_and_entity [SpeckleObjects::Base] base object to serialize.
-      # @return [String, Integer, Array<Object>] base id, total_children_count of base and batches
-      def serialize(base_and_entity, speckle_state, preferences)
-        serializer = SpeckleConnector::Converters::BaseObjectSerializer.new(speckle_state, stream_id, preferences)
-        t = Time.now.to_f
-        id = serializer.serialize(base_and_entity)
-        batches = serializer.batch_objects
-        # write_to_speckle_folder(id, batches)
-        puts "Generating traversed object elapsed #{Time.now.to_f - t} s"
-        base_total_children_count = serializer.total_children_count(id)
-        return id, base_total_children_count, batches, serializer.speckle_state
-      end
-
-      def write_to_speckle_folder(id, batches)
-        folder_path = "#{HOME_PATH}/Speckle"
-        file_path = "#{folder_path}/#{id}.json"
-        FileUtils.mkdir_p(folder_path) unless File.exist?(folder_path)
-        File.write(file_path, batches.first)
-      end
-
-      # @param entity [Sketchup::Entity] sketchup entity to convert Speckle.
-      # @param speckle_state [States::SpeckleState] the current speckle state of the {States::State}
-      # @param parent [Symbol, String] parent of the Sketchup Entity to be converted.
-      # rubocop:disable Metrics/MethodLength
-      def convert(entity, preferences, speckle_state, parent = :base)
-        convert = method(:convert)
-
-        if entity.is_a?(Sketchup::Edge)
-          line = SpeckleObjects::Geometry::Line.from_edge(entity, @units, preferences[:model]).to_h
-          return speckle_state, [line, [entity]]
-        end
-
-        if entity.is_a?(Sketchup::Face)
-          mesh = SpeckleObjects::Geometry::Mesh.from_face(entity, @units, preferences[:model])
-          return speckle_state, [mesh, [entity]]
-        end
-
-        if entity.is_a?(Sketchup::Group)
-          new_speckle_state, block_instance = SpeckleObjects::Other::BlockInstance.from_group(
-            entity, @units, preferences, speckle_state, &convert
-          )
-          speckle_state = new_speckle_state
-          return speckle_state, [block_instance, [entity]]
-        end
-
-        if entity.is_a?(Sketchup::ComponentInstance)
-          new_speckle_state, block_instance = SpeckleObjects::Other::BlockInstance.from_component_instance(
-            entity, @units, preferences, speckle_state, &convert
-          )
-          speckle_state = new_speckle_state
-          return speckle_state, [block_instance, [entity]]
-        end
-
-        if entity.is_a?(Sketchup::ComponentDefinition)
-          new_speckle_state, block_definition = SpeckleObjects::Other::BlockDefinition.from_definition(
-            entity, @units, @definitions, preferences, speckle_state, parent, &convert
-          )
-          speckle_state = new_speckle_state
-          return speckle_state, [block_definition, [entity]]
-        end
-
-        return speckle_state, nil
-      end
-      # rubocop:enable Metrics/MethodLength
-
-      # Create layers -> {Hash{Symbol=>Array}} from sketchup model with empty array as hash entry values.
-      # This method add first headless layers (not belong to any folder),
-      # then goes through each folder, their sub-folders and their layers.
-      # @return [Hash{Symbol=>Array}] layers from sketchup model with empty array as hash entry values.
-      def add_all_layers
-        # add headless layers
-        layer_objects = add_layers(sketchup_model.layers.layers)
-        # add layers from folders
-        add_layers_from_folders(sketchup_model.layers.folders, layer_objects)
-        layer_objects
-      end
-
-      # @param layers [Array<Sketchup::Layer>] layers in sketchup model
-      # @return [Hash{Symbol=>Array}] layers with empty array value.
-      def add_layers(layers, layer_objects = {}, parent_name = '')
-        layers.each do |layer|
-          layer_name = parent_name.empty? ? "@#{layer.display_name}" : "#{parent_name}::#{layer.display_name}"
-          layer_objects[layer_name] = []
-        end
-        layer_objects
-      end
-
-      # @param folders [Array<Sketchup::LayerFolder>] layer folders in sketchup model.
-      # @param layer_objects [Hash{Symbol=>Array}] layer objects to fill in.
-      # @param parent_name [String] parent folder name to structure layer path before send to Speckle.
-      #  ex: "@#{parent_name}::#{layer_name}"
-      def add_layers_from_folders(folders, layer_objects, parent_name = '')
-        folders.each do |folder|
-          folder_name = parent_name.empty? ? "@#{folder.display_name}" : "#{parent_name}::#{folder.display_name}"
-          add_layers(folder.layers, layer_objects, folder_name)
-          add_layers_from_folders(folder.folders, layer_objects, folder_name) unless folder.folders.empty?
-        end
-      end
-
-      # Find layer path of given Sketchup entity.
-      # @param entity [Sketchup::Entity] entity to find root layer.
-      # @return [String] layer path of Sketchup entity.
-      def entity_layer_path(entity)
-        layer_name = entity.layer.display_name
-        if entity.layer.folder.nil?
-          "@#{layer_name}"
-        else
-          folders = folder_name(entity.layer.folder)
-          path = ''
-          folders.reverse.each do |folder|
-            path += "#{folder}::"
-          end
-          "@#{path}#{layer_name}"
-        end
-      end
-
-      # Nested method to retrieve sub-folders until nothing found.
-      # @return [Array<String>] folder names as list from bottom to top. Might need to be reversed if you want to see
-      #  from top to bottom.
-      def folder_name(folder, folders = [])
-        if folder.folder.nil?
-          folders.push(folder.display_name)
-        else
-          folder_name(folder.folder, folders.push(folder.display_name))
-        end
-      end
-
-      private
-
-      def get_camera_direction(cam)
-        SpeckleObjects::Geometry::Vector.new(
-          SpeckleObjects::Geometry.length_to_speckle(cam.direction[0], @units),
-          SpeckleObjects::Geometry.length_to_speckle(cam.direction[1], @units),
-          SpeckleObjects::Geometry.length_to_speckle(cam.direction[2], @units),
-          @units
-        )
-      end
-
-      def get_camera_target(cam)
-        SpeckleObjects::Geometry::Point.new(
-          SpeckleObjects::Geometry.length_to_speckle(cam.target[0], @units),
-          SpeckleObjects::Geometry.length_to_speckle(cam.target[1], @units),
-          SpeckleObjects::Geometry.length_to_speckle(cam.target[2], @units),
-          @units
-        )
-      end
-
-      def get_camera_origin(camera)
-        SpeckleObjects::Geometry::Point.new(
-          SpeckleObjects::Geometry.length_to_speckle(camera.eye[0], @units),
-          SpeckleObjects::Geometry.length_to_speckle(camera.eye[1], @units),
-          SpeckleObjects::Geometry.length_to_speckle(camera.eye[2], @units),
-          @units
-        )
-      end
-    end
-  end
-end

speckle_connector/src/sketchup_model/definitions/definitions.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../constants/dict_constants'
-
-module SpeckleConnector
-  # Operations related to {SketchupModel}.
-  module SketchupModel
-    # Definitions to store for entities.
-    class Definitions
-      def self.from_sketchup_model(model)
-        definitions = model.definitions
-        definitions = definitions.select do |definition|
-          !definition.attribute_dictionaries.nil? &&
-            definition.attribute_dictionaries.any? { |dict| dict.name == SPECKLE_BASE_OBJECT }
-        end
-        Definitions.new(definitions)
-      end
-
-      def add_definition(definition)
-        old_definition = @definitions_by_guid[definition.guid]
-        return self if definition == old_definition
-
-        new_definitions = @definitions.append(definition)
-        Definitions.new(new_definitions)
-      end
-
-      def initialize(definitions = [])
-        @definitions = definitions
-        @definitions_by_name = definitions.collect do |definition|
-          [definition.name, definition]
-        end.to_h.freeze
-        @definitions_by_guid = definitions.collect do |definition|
-          [definition.guid, definition]
-        end.to_h.freeze
-        freeze
-      end
-
-      def by_guid(guid)
-        @definitions_by_guid[guid]
-      end
-
-      def by_name(name)
-        @definitions_by_name[name]
-      end
-    end
-  end
-end

speckle_connector/src/sketchup_model/materials/materials.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../constants/mat_constants'
-
-module SpeckleConnector
-  # Operations related to {SketchupModel}.
-  module SketchupModel
-    # Materials to store for entities.
-    class Materials
-      def self.from_sketchup_model(model)
-        materials = model.materials
-        materials = materials.select do |material|
-          !material.attribute_dictionaries.nil? &&
-            material.attribute_dictionaries.any? { |dict| dict.name == MAT_DICTIONARY }
-        end
-        mat_hash = materials.collect { |material| [material.get_attribute(MAT_DICTIONARY, MAT_ID), material] }.to_h
-        Materials.new(mat_hash)
-      end
-
-      def initialize(material_hash = {})
-        @materials_by_id = material_hash.freeze
-        @id_by_materials = material_hash.collect { |id, material| [material, id] }.to_h.freeze
-        freeze
-      end
-
-      def add_material(id, material)
-        old_material = @materials_by_id[id.to_sym]
-        return self if material == old_material
-
-        new_material_hash = @materials_by_id.merge({ id.to_sym => material })
-        Materials.new(new_material_hash)
-      end
-
-      def by_id(id)
-        @materials_by_id[id.to_sym]
-      end
-
-      def material_id(material)
-        @id_by_materials[material]
-      end
-
-      def add_speckle_material
-        @materials_by_id[MAT_ADD]
-      end
-
-      def edit_speckle_material
-        @materials_by_id[MAT_EDIT]
-      end
-
-      def remove_speckle_material
-        @materials_by_id[MAT_REMOVE]
-      end
-    end
-  end
-end

speckle_connector/src/speckle_objects/built_elements/view3d.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../base'
-require_relative '../../constants/type_constants'
-require_relative '../../speckle_objects/geometry/point'
-require_relative '../../speckle_objects/geometry/vector'
-
-module SpeckleConnector
-  module SpeckleObjects
-    module BuiltElements
-      # View3d object represents scenes on Sketchup.
-      class View3d < Base
-        SPECKLE_TYPE = OBJECTS_BUILTELEMENTS_VIEW3D
-
-        # @param name [String] name of the scene
-        # @param origin [SpeckleObjects::Geometry::Point] origin (eye) of the view.
-        # @param target [SpeckleObjects::Geometry::Point] target of the view.
-        # @param direction [SpeckleObjects::Geometry::Vector] direction of the view from eye to target.
-        # @param up_direction [SpeckleObjects::Geometry::Vector] up direction of the view.
-        # @param is_perspective [Boolean] whether view is perspective or not.
-        # @param lens [Boolean] fov value of the view camera.
-        # @param units [String] units of the camera.
-        # @param application_id [String] application_id of the view.
-        # @param update_properties [Hash{Symbol=>boolean}] properties of the view.
-        # @param rendering_options [Hash{Symbol=>boolean}] rendering options of the view.
-        # rubocop:disable Metrics/ParameterLists
-        def initialize(name, origin, target, direction, up_direction,
-                       is_perspective, lens, units, application_id, update_properties, rendering_options)
-          super(
-            speckle_type: SPECKLE_TYPE,
-            total_children_count: 0,
-            application_id: application_id,
-            id: nil
-          )
-          self[:name] = name
-          self[:origin] = origin
-          self[:target] = target
-          self[:forwardDirection] = direction
-          self[:upDirection] = up_direction
-          self[:isOrthogonal] = !is_perspective
-          self[:lens] = lens
-          self[:units] = units
-          self[:update_properties] = update_properties
-          self[:rendering_options] = rendering_options
-        end
-        # rubocop:enable Metrics/ParameterLists
-
-        # @param obj [Hash] commit object.
-        # @param sketchup_model [Sketchup::Model] active sketchup model.
-        # rubocop:disable Metrics/AbcSize
-        # rubocop:disable Metrics/PerceivedComplexity
-        # rubocop:disable Metrics/CyclomaticComplexity
-        def self.to_native(obj, sketchup_model)
-          views = collect_views(obj)
-          return if views.empty?
-
-          views.each do |view|
-            next unless view['speckle_type'] == 'Objects.BuiltElements.View:Objects.BuiltElements.View3D'
-
-            name = view['name'] || view['id']
-            next if sketchup_model.pages.any? { |page| page.name == name }
-
-            origin = view['origin']
-            target = view['target']
-            lens = view['lens'] || 50
-            origin = SpeckleObjects::Geometry::Point.to_native(origin['x'], origin['y'], origin['z'], origin['units'])
-            target = SpeckleObjects::Geometry::Point.to_native(target['x'], target['y'], target['z'], target['units'])
-            # Set camera position before creating scene on it.
-            my_camera = Sketchup::Camera.new(origin, target, [0, 0, 1], !view['isOrthogonal'], lens)
-            sketchup_model.active_view.camera = my_camera
-            sketchup_model.pages.add(name)
-            page = sketchup_model.pages[name]
-            set_page_update_properties(page, view['update_properties']) if view['update_properties']
-            set_rendering_options(page.rendering_options, view['rendering_options']) if view['rendering_options']
-          end
-        end
-        # rubocop:enable Metrics/AbcSize
-        # rubocop:enable Metrics/PerceivedComplexity
-        # rubocop:enable Metrics/CyclomaticComplexity
-
-        def self.collect_views(obj)
-          views = []
-          views += obj.filter_map do |_key, value|
-            if value.is_a?(Array) &&
-               value.any? { |v| v['speckle_type'] == OBJECTS_BUILTELEMENTS_VIEW3D }
-              value
-            end
-          end
-          views.flatten.select { |view| view['speckle_type'] == OBJECTS_BUILTELEMENTS_VIEW3D }
-        end
-      end
-    end
-  end
-end

speckle_connector/src/speckle_objects/geometry/length.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../convertors/units'
-
-module SpeckleConnector
-  module SpeckleObjects
-    # Geometric objects to convert speckle.
-    module Geometry
-      def self.length_to_speckle(length, units)
-        length.__send__("to_#{SpeckleConnector::Converters::SKETCHUP_UNIT_STRINGS[units]}")
-      end
-
-      def self.length_to_native(length, units)
-        length.__send__(SpeckleConnector::Converters::SKETCHUP_UNIT_STRINGS[units])
-      end
-    end
-  end
-end

speckle_connector/src/speckle_objects/geometry/line.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'length'
-require_relative 'point'
-require_relative 'bounding_box'
-require_relative '../base'
-require_relative '../primitive/interval'
-require_relative '../../sketchup_model/dictionary/dictionary_handler'
-
-module SpeckleConnector
-  module SpeckleObjects
-    module Geometry
-      # Line object definition for Speckle.
-      class Line < Base
-        SPECKLE_TYPE = 'Objects.Geometry.Line'
-
-        # @param start_pt [Geometry::Point] start point speckle object of the speckle line.
-        # @param end_pt [Geometry::Point] end point speckle object of the speckle line.
-        # @param domain [Primitive::Interval] interval speckle object of the speckle line -represents domain.
-        # @param bbox [Geometry::BoundingBox] bounding box speckle object of the speckle line.
-        # @param units [String] units of the speckle line.
-        # @param application_id [String, nil] entity id of the {Sketchup::Edge} that represents to the speckle line.
-        # rubocop:disable Metrics/ParameterLists
-        def initialize(start_pt:, end_pt:, domain:, bbox:, units:, sketchup_attributes: {}, application_id: nil)
-          super(
-              speckle_type: 'Objects.Geometry.Line',
-              total_children_count: 0,
-              application_id: application_id,
-              id: nil
-            )
-          self[:start] = start_pt
-          self[:end] = end_pt
-          self[:domain] = domain
-          self[:bbox] = bbox
-          self[:units] = units
-          self[:sketchup_attributes] = sketchup_attributes if sketchup_attributes.any?
-        end
-        # rubocop:enable Metrics/ParameterLists
-
-        # @param edge [Sketchup::Edge] edge to convert line.
-        def self.from_edge(edge, units, model_preferences)
-          dictionaries = {}
-          if model_preferences[:include_entity_attributes] && model_preferences[:include_edge_entity_attributes]
-            dictionaries = SketchupModel::Dictionary::DictionaryHandler.attribute_dictionaries_to_speckle(edge)
-          end
-          att = dictionaries.any? ? { dictionaries: dictionaries } : {}
-          start_pt = Geometry::Point.from_vertex(edge.start.position, units)
-          end_pt = Geometry::Point.from_vertex(edge.end.position, units)
-          domain = Primitive::Interval.from_numeric(0, Float(edge.length), units)
-          bbox = Geometry::BoundingBox.from_bounds(edge.bounds, units)
-          Line.new(
-            start_pt: start_pt,
-            end_pt: end_pt,
-            domain: domain,
-            bbox: bbox,
-            units: units,
-            sketchup_attributes: att,
-            application_id: edge.persistent_id.to_s
-          )
-        end
-
-        # @param _state [States::State] state of the application.
-        # @param line [Object] object represents Speckle line.
-        # @param layer [Sketchup::Layer] layer to add {Sketchup::Edge} into it.
-        # @param entities [Sketchup::Entities] entities collection to add {Sketchup::Edge} into it.
-        # rubocop:disable Metrics/AbcSize
-        def self.to_native(state, line, layer, entities, &_convert_to_native)
-          if line.key?('value')
-            values = line['value']
-            points = values.each_slice(3).to_a.map { |pt| Point.to_native(pt[0], pt[1], pt[2], line['units']) }
-            points.push(points[0]) if line['closed']
-            edges = entities.add_edges(*points)
-          else
-            start_pt = Point.to_native(line['start']['x'], line['start']['y'], line['start']['z'], line['units'])
-            end_pt = Point.to_native(line['end']['x'], line['end']['y'], line['end']['z'], line['units'])
-            edges = entities.add_edges(start_pt, end_pt)
-          end
-          edges.each do |edge|
-            edge.layer = layer
-            unless line['sketchup_attributes'].nil?
-              SketchupModel::Dictionary::DictionaryHandler
-                .attribute_dictionaries_to_native(edge, line['sketchup_attributes']['dictionaries'])
-            end
-          end
-          return state, edges
-        end
-        # rubocop:enable Metrics/AbcSize
-
-        def self.test_line(start_point, end_point, units)
-          domain = Primitive::Interval.from_numeric(0, 5, units)
-          bbox = Geometry::BoundingBox.test_bounds(units)
-          Line.new(
-            start_pt: start_point,
-            end_pt: end_point,
-            domain: domain,
-            bbox: bbox,
-            application_id: '',
-            units: units
-          )
-        end
-      end
-    end
-  end
-end

speckle_connector/src/speckle_objects/other/color.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module SpeckleConnector
-  module SpeckleObjects
-    module Others
-      # Color object transformations between sketchup and speckle.
-      class Color
-        # @param color [Sketchup::Color] color to convert speckle object
-        def self.to_speckle(color)
-          {
-            red: color.red,
-            green: color.green,
-            blue: color.blue,
-            alpha: color.alpha
-          }
-        end
-
-        def self.to_native(speckle_color)
-          Sketchup::Color.new(speckle_color['red'], speckle_color['green'],
-                              speckle_color['blue'], speckle_color['alpha'])
-        end
-      end
-    end
-  end
-end

speckle_connector/src/states/speckle_state.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../immutable/immutable'
-require_relative '../callbacks/callback_message'
-require_relative '../speckle_entities/speckle_entity'
-
-module SpeckleConnector
-  module States
-    # State of the speckle on ruby.
-    class SpeckleState
-      include Immutable::ImmutableUtils
-
-      # @return [ImmutableHash{Integer=>SpeckleEntities::SpeckleEntity}] persistent_id of the sketchup entity and
-      #  corresponding speckle entity
-      attr_reader :speckle_entities
-
-      # @return [Array] accounts on appdata.
-      attr_reader :accounts
-
-      # @return [Hash{Class => Observer}] the observer objects that are used to attach to objects in Sketchup to collect
-      #  events that are triggered from Sketchup
-      attr_reader :observers
-
-      # @return [Hash] queue to send to server.
-      attr_reader :message_queue
-
-      # @return [Hash] stream queue to send to server.
-      attr_reader :stream_queue
-
-      # @return [Relations::ManyToOneRelation] relations between objects.
-      attr_accessor :relation
-
-      def initialize(accounts, observers, queue, stream_queue)
-        @accounts = accounts
-        @observers = observers
-        @message_queue = queue
-        @stream_queue = stream_queue
-        @speckle_entities = Immutable::EmptyHash
-        @relation = Relations::ManyToOneRelation.new
-      end
-
-      # @param callback_name [String] name of the callback command
-      # @param stream_id [String] id of the stream
-      # @param parameters [Array<String>] parameters of the callback method call
-      def with_add_queue(callback_name, stream_id, parameters)
-        next_queue_message = Callbacks::CallbackMessage.serialize(callback_name, stream_id, parameters)
-        new_queue = message_queue.merge({ "#{callback_name}": next_queue_message })
-        with(:@message_queue => new_queue)
-      end
-
-      def with_invalid_streams_queue
-        new_queue = message_queue.merge({ "updateInvalidStreams":
-                                            "updateInvalidStreams(#{JSON.generate(invalid_streams)})" })
-        with(:@message_queue => new_queue)
-      end
-
-      def with_empty_invalid_streams_queue
-        new_queue = message_queue.merge({ "updateInvalidStreams":
-                                            "updateInvalidStreams(#{JSON.generate([])})" })
-        with(:@message_queue => new_queue)
-      end
-
-      def with_accounts(new_accounts)
-        with(:@accounts => new_accounts)
-      end
-
-      def with_speckle_entity(traversed_entity)
-        new_speckle_entities = speckle_entities.put(traversed_entity.application_id, traversed_entity)
-        with_speckle_entities(new_speckle_entities)
-      end
-
-      def with_speckle_entities(new_speckle_entities)
-        with(:@speckle_entities => new_speckle_entities)
-      end
-
-      def with_relation(new_relation)
-        with(:@relation => new_relation)
-      end
-
-      def invalid_streams
-        speckle_entities.collect do |_id, speckle_entity|
-          speckle_entity.invalid_stream_ids
-        end.reduce([], :concat).uniq
-      end
-    end
-  end
-end

speckle_connector/src/ui/view.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module SpeckleConnector
-  module Ui
-    # The abstract class for view to send data to a user interface.
-    class View
-      def update_view(_state)
-        raise NotImplementedError, 'Implement in a subclass'
-      end
-    end
-  end
-end

speckle_connector/src/ui/vue_view.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'view'
-require_relative '../ui/dialog'
-require_relative '../constants/path_constants'
-
-require_relative '../commands/send_selection'
-require_relative '../commands/receive_objects'
-require_relative '../commands/action_command'
-require_relative '../commands/dialog_ready'
-require_relative '../commands/save_stream'
-require_relative '../commands/remove_stream'
-require_relative '../commands/notify_connected'
-require_relative '../commands/user_preferences_updated'
-require_relative '../commands/model_preferences_updated'
-require_relative '../commands/activate_diffing'
-
-require_relative '../actions/reload_accounts'
-require_relative '../actions/load_saved_streams'
-require_relative '../actions/init_local_accounts'
-require_relative '../actions/collect_preferences'
-require_relative '../actions/deactivate_diffing'
-require_relative '../actions/collect_versions'
-
-module SpeckleConnector
-  module Ui
-    SPECKLE_UI_ID = 'speckle_ui'
-    VUE_UI_HTML = Pathname.new(File.join(SPECKLE_SRC_PATH, '..', 'vue_ui', 'index.html')).cleanpath.to_s
-
-    # View that provided by vue.js
-    class VueView < View
-      CMD_UPDATE_VIEW = 'speckle.updateView'
-
-      # @param dialog_specs [Hash] the specifications for the {SpeckleConnector::Ui::Dialog}.
-      # @param app [App::SpeckleConnectorApp] the reference to the app object
-      def initialize(dialog_specs, app)
-        super()
-        @dialog_specs = dialog_specs
-        @app = app
-      end
-
-      # Show the HTML dialog
-      def show
-        dialog.show
-      end
-
-      # @return [SpeckleConnector::Ui::Dialog] wrapper for the {Sketchup::HTMLDialog}
-      def dialog
-        @dialog ||= SpeckleConnector::Ui::Dialog.new(commands: commands, **@dialog_specs)
-      end
-
-      def update_view(_state)
-        # TODO: If you want to send data to dialog additionally, consume this method.
-        #  App object triggers this method by ui_controller
-      end
-
-      private
-
-      def commands
-        @commands ||= {
-          dialog_ready: Commands::DialogReady.new(@app),
-          send_selection: Commands::SendSelection.new(@app),
-          receive_objects: Commands::ReceiveObjects.new(@app),
-          reload_accounts: Commands::ActionCommand.new(@app, Actions::ReloadAccounts),
-          init_local_accounts: Commands::ActionCommand.new(@app, Actions::InitLocalAccounts),
-          load_saved_streams: Commands::ActionCommand.new(@app, Actions::LoadSavedStreams),
-          save_stream: Commands::SaveStream.new(@app),
-          remove_stream: Commands::RemoveStream.new(@app),
-          notify_connected: Commands::NotifyConnected.new(@app),
-          collect_preferences: Commands::ActionCommand.new(@app, Actions::CollectPreferences),
-          collect_versions: Commands::ActionCommand.new(@app, Actions::CollectVersions),
-          user_preferences_updated: Commands::UserPreferencesUpdated.new(@app),
-          model_preferences_updated: Commands::ModelPreferencesUpdated.new(@app),
-          activate_diffing: Commands::ActivateDiffing.new(@app),
-          deactivate_diffing: Commands::ActionCommand.new(@app, Actions::DeactivateDiffing)
-        }.freeze
-      end
-    end
-  end
-end

speckle_connector_3.rb

@@ -4,7 +4,7 @@ require 'sketchup'
 require 'extensions'
 
 # Speckle connector module to enable multiplayer mode ON!
-module SpeckleConnector
+module SpeckleConnector3
   # Version - patched by CI
   CONNECTOR_VERSION = '0.0.0'
 
@@ -23,11 +23,11 @@ module SpeckleConnector
   PATH = File.join(PATH_ROOT, folder_name).freeze
 
   # Run from localhost or from build files
-  DEV_MODE = false
+  DEV_MODE = true
   puts("Loading Speckle Connector v#{CONNECTOR_VERSION} from #{DEV_MODE ? 'dev' : 'build'}")
 
   unless file_loaded?(__FILE__)
-    ex = SketchupExtension.new('Speckle SketchUp', File.join(PATH, 'bootstrap'))
+    ex = SketchupExtension.new('Speckle SketchUp v3', File.join(PATH, 'bootstrap'))
     ex.description = 'Speckle Connector for SketchUp'
     ex.version     = CONNECTOR_VERSION
     ex.copyright   = 'AEC Systems Ltd.'

speckle_connector_3/bootstrap.rb

@@ -2,7 +2,8 @@
 
 require 'sketchup'
 require 'pathname'
-require 'speckle_connector/debug'
+require 'speckle_connector_3/debug'
+require_relative 'src/log/log'
 require_relative 'src/ui/sketchup_ui'
 require_relative 'src/ui/ui_controller'
 require_relative 'src/commands/menu_command_handler'
@@ -12,7 +13,7 @@ require_relative 'src/states/initial_state'
 require_relative 'src/commands/speckle_menu_commands'
 
 # Speckle Connector on SketchUp to enable Multiplayer mode ON!
-module SpeckleConnector
+module SpeckleConnector3
   SKETCHUP_VERSION = Sketchup.version.to_i
 
   dir = __dir__.dup
@@ -23,9 +24,9 @@ module SpeckleConnector
     sketchup_ui = Ui::SketchupUi.new
     ui_controller = Ui::UiController.new(sketchup_ui)
     menu_commands = Commands::MenuCommandHandler.new
-    user_state = SpeckleConnector::States::UserState.new({})
-    initial_state = SpeckleConnector::States::InitialState.new(user_state)
-    app = SpeckleConnector::App::SpeckleConnectorApp.new(menu_commands, initial_state, ui_controller)
+    user_state = SpeckleConnector3::States::UserState.new({})
+    initial_state = SpeckleConnector3::States::InitialState.new(user_state)
+    app = SpeckleConnector3::App::SpeckleConnectorApp.new(menu_commands, initial_state, ui_controller)
     # Add menu commands to SketchUp and Speckle application
     Commands::SpeckleMenuCommands.add_initial_commands!(app)
     app

speckle_connector_3/debug.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Speckle connector module to enable multiplayer mode ON!
-module SpeckleConnector
+module SpeckleConnector3
   # from thomthom
   # https://github.com/thomthom/true-bend/blob/master/src/tt_truebend/debug.rb
 
@@ -15,7 +15,9 @@ module SpeckleConnector
   def self.reload
     load(__FILE__)
     pattern = File.join(__dir__, '**/*.rb')
-    Dir.glob(pattern).each { |file| load(file) }
+    # TODO: Here is a opportunity to improve reloading process.
+    #  We can cache last edited time of the each file later to check which file need to be reloaded.
+    Dir.glob(pattern).each { |file| load(file) unless file.include?('bootstrap') }
        .size
   end
   # rubocop:enable SketchupSuggestions/FileEncoding

speckle_connector_3/src/accounts/accounts.rb

@@ -4,9 +4,10 @@ require 'JSON'
 require_relative '../ext/sqlite3'
 require_relative '../constants/path_constants'
 
-module SpeckleConnector
+module SpeckleConnector3
   # Accounts to communicate with models on user's account.
   module Accounts
+    # Load accounts from user's app data.
     def self.load_accounts
       db_path = SPECKLE_ACCOUNTS_DB_PATH
       unless File.exist?(db_path)
@@ -23,9 +24,21 @@ module SpeckleConnector
       rows.map { |row| JSON.parse(row[1]) }
     end
 
+    def self.get_account_by_id(id)
+      accounts = load_accounts
+      accounts.select { |acc| acc['id'] == id }[0]
+    end
+
+    # Default account on the user computer.
     def self.default_account
       accounts = load_accounts
       accounts.select { |acc| acc['isDefault'] }[0] || accounts[0]
     end
+
+    # Try to get local server account for debug/test purposes.
+    def self.try_get_local_server_account
+      accounts = load_accounts
+      accounts.select { |acc| acc['serverInfo']['url'].include?('localhost') }[0] || nil
+    end
   end
 end

speckle_connector_3/src/actions/action.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module SpeckleConnector
+module SpeckleConnector3
   module Actions
     # State changer object.
     class Action

speckle_connector_3/src/actions/activate_diffing.rb

@@ -3,7 +3,7 @@
 require_relative 'action'
 require_relative 'deactivate_diffing'
 
-module SpeckleConnector
+module SpeckleConnector3
   module Actions
     # Deactivate diffing for stream.
     class ActivateDiffing < Action
@@ -15,7 +15,7 @@ module SpeckleConnector
       # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
       # @return [States::State] the new updated state object
       def update_state(state)
-        state = DeactivateDiffing.update_state(state, {})
+        state = DeactivateDiffing.update_state(state, nil, {})
         puts "Diffing activated for #{@stream_id}"
         speckle_entities = state.speckle_state.speckle_entities
         invalid_speckle_entities = speckle_entities.select do |_id, entity|

speckle_connector_3/src/actions/add_material.rb

@@ -2,7 +2,7 @@
 
 require_relative 'action'
 
-module SpeckleConnector
+module SpeckleConnector3
   module Actions
     # Adds material to speckle state and Sketchup.
     class AddMaterial < Action

speckle_connector_3/src/actions/apply_mappings.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative 'mapped_entities_updated'
+require_relative 'events/selection_event_action'
+require_relative '../sketchup_model/dictionary/speckle_schema_dictionary_handler'
+
+module SpeckleConnector3
+  module Actions
+    # Apply mappings for selected entities.
+    class ApplyMappings < Action
+      def initialize(entities_to_map, method, category, family,
+                     family_type, level, name, is_definition)
+        super()
+        @entities_to_map = entities_to_map
+        @method = method
+        @category = category
+        @name = name
+        @family = family
+        @family_type = family_type
+        @level = level
+        @is_definition = is_definition
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/MethodLength
+      def update_state(state)
+        sketchup_model = state.sketchup_state.sketchup_model
+        entities = if sketchup_model.active_path.nil?
+                     sketchup_model.entities
+                   else
+                     sketchup_model.active_path.last.definition.entities
+                   end
+
+        # Collect entities from entity ids that comes from UI as list
+        entities_to_map = entities.select { |e| @entities_to_map.include?(e.persistent_id.to_s) }
+
+        # Switch to definitions if all entities are component instance and UI flag shows that
+        if entities_to_map.all? { |e| e.is_a?(Sketchup::ComponentInstance) } && @is_definition
+          entities_to_map = entities_to_map.collect(&:definition).uniq
+        end
+
+        # Store speckle state to update with mapped entities.
+        speckle_state = state.speckle_state
+        entities_to_map.each do |entity|
+          name = if @name == '<Mixed>'
+                   entity.respond_to?(:name) ? entity.name : ''
+                 else
+                   @name
+                 end
+          SketchupModel::Dictionary::SpeckleSchemaDictionaryHandler.set_attribute(entity, :category, @category)
+          SketchupModel::Dictionary::SpeckleSchemaDictionaryHandler.set_attribute(entity, :name, name)
+          SketchupModel::Dictionary::SpeckleSchemaDictionaryHandler.set_attribute(entity, :method, @method)
+          SketchupModel::Dictionary::SpeckleSchemaDictionaryHandler.set_attribute(entity, :family, @family)
+          SketchupModel::Dictionary::SpeckleSchemaDictionaryHandler.set_attribute(entity, :family_type, @family_type)
+          SketchupModel::Dictionary::SpeckleSchemaDictionaryHandler.set_attribute(entity, :level, @level)
+          speckle_state = speckle_state.with_mapped_entity(entity)
+        end
+
+        new_state = MappedEntitiesUpdated.update_state(state.with_speckle_state(speckle_state))
+        Events::SelectionEventAction.update_state(new_state, { apply: true })
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

speckle_connector_3/src/actions/base_actions/add_model.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'add_send_model_card'
+require_relative 'add_receive_model_card'
+require_relative '../action'
+require_relative '../../cards/send_card'
+require_relative '../../cards/receive_card'
+require_relative '../../filters/send/everything_filter'
+require_relative '../../filters/send/selection_filter'
+require_relative '../../filters/send_filters'
+require_relative '../../sketchup_model/dictionary/model_card_dictionary_handler'
+
+module SpeckleConnector3
+  module Actions
+    # Action to add send card.
+    class AddModel < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, resolve_id, data)
+        if data['typeDiscriminator'] == 'SenderModelCard'
+          Actions::AddSendModelCard.update_state(state, resolve_id, data)
+        else
+          Actions::AddReceiveModelCard.update_state(state, resolve_id, data)
+        end
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/base_actions/add_receive_model_card.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../action'
+require_relative '../../cards/send_card'
+require_relative '../../cards/receive_card'
+require_relative '../../filters/send/everything_filter'
+require_relative '../../filters/send/selection_filter'
+require_relative '../../filters/send_filters'
+require_relative '../../sketchup_model/dictionary/model_card_dictionary_handler'
+
+module SpeckleConnector3
+  module Actions
+    # Action to add receive model card.
+    class AddReceiveModelCard < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, resolve_id, data)
+        model_card_id = data['modelCardId']
+        account_id = data['accountId']
+        project_id = data['projectId']
+        model_id = data['modelId']
+        project_name = data['projectName']
+        model_name = data['modelName']
+        expired = data['expired']
+        selected_version_id = data['selectedVersionId']
+        latest_version_id = data['latestVersionId']
+        has_dismissed_update_warning = data['hasDismissedUpdateWarning']
+        baked_object_ids = data['bakedObjectIds'].nil? ? nil : data['bakedObjectIds'].values
+
+        receive_card = Cards::ReceiveCard.new(model_card_id, account_id,
+                                              project_id, model_id,
+                                              project_name, model_name,
+                                              selected_version_id, latest_version_id,
+                                              has_dismissed_update_warning, expired, baked_object_ids)
+        SketchupModel::Dictionary::ModelCardDictionaryHandler
+          .save_receive_card_to_model(receive_card, state.sketchup_state.sketchup_model)
+        new_speckle_state = state.speckle_state.with_receive_card(receive_card)
+        state = state.with_speckle_state(new_speckle_state)
+        js_script = "baseBinding.receiveResponse('#{resolve_id}')"
+        return state.with_add_queue_js_command('addReceiveCard', js_script)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/base_actions/add_send_model_card.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../action'
+require_relative '../../cards/send_card'
+require_relative '../../cards/receive_card'
+require_relative '../../filters/send/everything_filter'
+require_relative '../../filters/send/selection_filter'
+require_relative '../../filters/send_filters'
+require_relative '../../settings/card_settings'
+require_relative '../../sketchup_model/dictionary/model_card_dictionary_handler'
+
+module SpeckleConnector3
+  module Actions
+    # Action to add send model card.
+    class AddSendModelCard < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, resolve_id, data)
+        send_filter = Filters::SendFilters.get_filter_from_ui_data(data['sendFilter'])
+        # settings = Settings::CardSetting.get_setting_from_ui_data(data['settings'])
+        # Init card and add to the state
+        send_card = Cards::SendCard.new(
+          data['modelCardId'],
+          data['accountId'],
+          data['projectId'],
+          data['projectName'],
+          data['modelId'],
+          data['modelName'],
+          data['latestCreatedVersionId'],
+          send_filter,
+          data['settings']
+        )
+
+        SketchupModel::Dictionary::ModelCardDictionaryHandler
+          .save_send_card_to_model(send_card, state.sketchup_state.sketchup_model)
+
+        new_speckle_state = state.speckle_state.with_send_card(send_card)
+        state = state.with_speckle_state(new_speckle_state)
+        # Resolve promise
+        js_script = "baseBinding.receiveResponse('#{resolve_id}')"
+        state.with_add_queue_js_command('addSendCard', js_script)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/base_actions/get_connector_version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../action'
+
+module SpeckleConnector3
+  module Actions
+    # Get connector version.
+    class GetConnectorVersion < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, resolve_id)
+        js_command = "baseBinding.receiveResponse('#{resolve_id}', '#{CONNECTOR_VERSION}')"
+        state.with_add_queue_js_command('getConnectorVersion', js_command)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/base_actions/get_document_state.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative '../action'
+require_relative '../../filters/send_filters'
+require_relative '../../sketchup_model/dictionary/model_card_dictionary_handler'
+
+module SpeckleConnector3
+  module Actions
+    # Gets document state.
+    class GetDocumentState < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, resolve_id)
+        send_cards_hash = SketchupModel::Dictionary::ModelCardDictionaryHandler
+                          .get_send_cards_from_dict(state.sketchup_state.sketchup_model)
+
+        # TODO: CONVERTER_V2: Extract into new actions
+        send_cards = send_cards_hash.collect do |id, card|
+          filter = Filters::SendFilters.get_filter_from_document(card['sendFilter'])
+          settings = Settings::CardSetting.get_filter_from_document(card['sendSettings'])
+          send_card = Cards::SendCard.new(
+            id,
+            card['account_id'],
+            card['project_id'],
+            card['project_name'],
+            card['model_id'],
+            card['model_name'],
+            card['latest_created_version_id'],
+            filter,
+            settings
+          )
+
+          new_speckle_state = state.speckle_state.with_send_card(send_card)
+          state = state.with_speckle_state(new_speckle_state)
+          {
+            modelCardId: send_card.model_card_id,
+            accountId: send_card.account_id,
+            projectId: send_card.project_id,
+            modelId: send_card.model_id,
+            sendFilter: send_card.send_filter,
+            settings: send_card.send_settings,
+            latestCreatedVersionId: send_card.latest_created_version_id,
+            typeDiscriminator: send_card.type_discriminator
+          }
+        end
+
+        receive_cards_hash = SketchupModel::Dictionary::ModelCardDictionaryHandler
+                             .get_receive_cards_from_dict(state.sketchup_state.sketchup_model)
+
+        # TODO: CONVERTER_V2: Extract into new actions
+        receive_cards = receive_cards_hash.collect do |id, card|
+          receive_card = Cards::ReceiveCard.new(id, card['account_id'], card['project_id'], card['model_id'],
+                                                card['project_name'], card['model_name'], card['selected_version_id'],
+                                                card['latest_version_id'], card['has_dismissed_update_warning'],
+                                                card['expired'], card['baked_object_ids'])
+
+          new_speckle_state = state.speckle_state.with_receive_card(receive_card)
+          state = state.with_speckle_state(new_speckle_state)
+          {
+            modelCardId: receive_card.model_card_id,
+            accountId: receive_card.account_id,
+            projectId: receive_card.project_id,
+            modelId: receive_card.model_id,
+            projectName: receive_card.project_name,
+            modelName: receive_card.model_name,
+            selectedVersionId: receive_card.selected_version_id,
+            latestVersionId: receive_card.latest_version_id,
+            hasDismissedUpdateWarning: receive_card.has_dismissed_update_warning,
+            expired: receive_card.expired,
+            bakedObjectIds: receive_card.baked_object_ids,
+            typeDiscriminator: receive_card.type_discriminator
+          }
+        end
+
+        model_state = { models: send_cards + receive_cards }
+
+        js_script = "baseBinding.receiveResponse('#{resolve_id}', #{model_state.to_json})"
+        state.with_add_queue_js_command('getDocumentState', js_script)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/base_actions/get_send_filters.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative '../action'
+require_relative '../../filters/send_filters'
+
+module SpeckleConnector3
+  module Actions
+    # Action to get send filter.
+    class GetSendFilters < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, resolve_id)
+        default_filters = Filters::SendFilters.get_default(state.sketchup_state.sketchup_model)
+        js_script = "sendBinding.receiveResponse('#{resolve_id}', #{default_filters.to_json})"
+        state.with_add_queue_js_command('getSendFilter', js_script)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/base_actions/get_send_settings.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../action'
+require_relative '../../settings/card_settings'
+
+module SpeckleConnector3
+  module Actions
+    # Action to get send settings.
+    class GetSendSettings < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, resolve_id)
+        # NOTE: below code is tested and works!
+        # default_settings = [
+        #   Settings::CardSetting.new(id: "includeAttributes", title: "Include Attributes", type: "boolean", value: true),
+        #   Settings::CardSetting.new(id: "test", title: "Test", type: "string", value: "a", enum: %w[a b c])
+        # ]
+        default_settings = []
+        js_script = "sendBinding.receiveResponse('#{resolve_id}', #{default_settings.to_json})"
+        state.with_add_queue_js_command('getSendSettings', js_script)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/base_actions/get_source_app_name.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../action'
+
+module SpeckleConnector3
+  module Actions
+    # Get source app name.
+    class GetSourceAppName < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, resolve_id)
+        js_command = "baseBinding.receiveResponse('#{resolve_id}', 'sketchup')"
+        state.with_add_queue_js_command('getSourceAppName', js_command)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/base_actions/get_source_app_version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../action'
+
+module SpeckleConnector3
+  module Actions
+    # Get source app version.
+    class GetSourceAppVersion < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, resolve_id)
+        js_command = "baseBinding.receiveResponse('#{resolve_id}', #{SKETCHUP_VERSION})"
+        state.with_add_queue_js_command('getSourceAppVersion', js_command)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/base_actions/highlight_model.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../action'
+require_relative '../../sketchup_model/query/entity'
+
+module SpeckleConnector3
+  module Actions
+    # Action to add send card.
+    class HighlightModel < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, resolve_id, model_card_id)
+        receiver_card = state.speckle_state.receive_cards[model_card_id]
+        sender_card = state.speckle_state.send_cards[model_card_id]
+        card = receiver_card || sender_card
+
+        objects_to_highlight = if card.type_discriminator == 'ReceiverModelCard'
+                                 state.speckle_state.receive_cards[model_card_id].baked_object_ids
+                               else
+                                 state.speckle_state.send_cards[model_card_id].send_filter.selected_object_ids
+                               end
+
+        SketchupModel::Utils::ViewUtils.highlight_entities(state.sketchup_state.sketchup_model, objects_to_highlight)
+
+        # Resolve promise
+        js_script = "baseBinding.receiveResponse('#{resolve_id}')"
+        state.with_add_queue_js_command('highlightModel', js_script)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/base_actions/highlight_objects.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../action'
+require_relative '../../sketchup_model/query/entity'
+require_relative '../../sketchup_model/utils/view_utils'
+
+module SpeckleConnector3
+  module Actions
+    # Action to add send card.
+    class HighlightObjects < Action
+      def self.update_state(state, resolve_id, object_ids)
+        SketchupModel::Utils::ViewUtils.highlight_entities(state.sketchup_state.sketchup_model, object_ids)
+
+        # Resolve promise
+        js_script = "baseBinding.receiveResponse('#{resolve_id}')"
+        state.with_add_queue_js_command('highlightObjects', js_script)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/base_actions/remove_model.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative '../action'
+require_relative '../../cards/send_card'
+require_relative '../../cards/receive_card'
+require_relative '../../filters/send/everything_filter'
+require_relative '../../filters/send/selection_filter'
+require_relative '../../filters/send_filters'
+require_relative '../../sketchup_model/dictionary/model_card_dictionary_handler'
+
+module SpeckleConnector3
+  module Actions
+    # Action to remove send card.
+    class RemoveModel < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, resolve_id, data)
+        SketchupModel::Dictionary::ModelCardDictionaryHandler.remove_card_dict(state.sketchup_state.sketchup_model, data)
+        new_speckle_state = if data['typeDiscriminator'] == 'ReceiverModelCard'
+                              state.speckle_state.without_receive_card(data['id'])
+                            else
+                              state.speckle_state.without_send_card(data['id'])
+                            end
+        state = state.with_speckle_state(new_speckle_state)
+        # Resolve promise
+        js_script = "baseBinding.receiveResponse('#{resolve_id}')"
+        state.with_add_queue_js_command('removeModel', js_script)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/base_actions/update_send_filter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative '../action'
+require_relative '../../sketchup_model/dictionary/model_card_dictionary_handler'
+
+module SpeckleConnector3
+  module Actions
+    # Action to update send filter.
+    class UpdateSendFilter < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, resolve_id, data, value)
+        SketchupModel::Dictionary::ModelCardDictionaryHandler.update_filter(state.sketchup_state.sketchup_model, data, value)
+
+        js_script = "sendBinding.receiveResponse('#{resolve_id}')"
+        state.with_add_queue_js_command('updateSendFilter', js_script)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/clear_mapper_source.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../sketchup_model/dictionary/speckle_entity_dictionary_handler'
+
+module SpeckleConnector3
+  module Actions
+    # Clear mapper source.
+    class ClearMapperSource < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, _resolve_id, _data)
+        new_speckle_state = state.speckle_state.with_removed_mapper_source
+        erase_levels(state)
+        state.with_speckle_state(new_speckle_state)
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      def self.erase_levels(state)
+        levels = state.sketchup_state.sketchup_model.definitions.select do |definition|
+          SketchupModel::Dictionary::SpeckleEntityDictionaryHandler.get_attribute(definition, :speckle_type) ==
+            OBJECTS_BUILTELEMENTS_REVIT_LEVEL
+        end
+        levels.each do |level|
+          level.entities.clear!
+          level.instances.each(&:erase!)
+        end
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/clear_mappings.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative 'mapped_entities_updated'
+require_relative 'events/selection_event_action'
+require_relative '../sketchup_model/dictionary/speckle_schema_dictionary_handler'
+
+module SpeckleConnector3
+  module Actions
+    # Clear mappings for selected entities.
+    class ClearMappings < Action
+      def initialize(entities_to_map, is_definition)
+        super()
+        @entities_to_map = entities_to_map
+        @is_definition = is_definition
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      def update_state(state)
+        sketchup_model = state.sketchup_state.sketchup_model
+        entities = if sketchup_model.active_path.nil?
+                     sketchup_model.entities
+                   else
+                     sketchup_model.active_path.last.definition.entities
+                   end
+
+        # Collect entities from entity ids that comes from UI as list
+        entities_to_map = entities.select { |e| @entities_to_map.include?(e.persistent_id.to_s) }
+
+        # Switch to definitions if all entities are component instance and UI flag shows that
+        if entities_to_map.all? { |e| e.is_a?(Sketchup::ComponentInstance) } && @is_definition
+          entities_to_map = entities_to_map.collect(&:definition).uniq
+        end
+
+        # Store speckle state to update with mapped entities.
+        speckle_state = state.speckle_state
+        entities_to_map.each do |entity|
+          SketchupModel::Dictionary::SpeckleSchemaDictionaryHandler.remove_dictionary(entity)
+          speckle_state = speckle_state.with_removed_mapped_entity(entity)
+        end
+
+        new_state = MappedEntitiesUpdated.update_state(state.with_speckle_state(speckle_state))
+        Events::SelectionEventAction.update_state(new_state, { clear: true })
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
+    end
+  end
+end

speckle_connector_3/src/actions/clear_mappings_from_table.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative 'mapped_entities_updated'
+require_relative 'events/selection_event_action'
+require_relative '../sketchup_model/dictionary/speckle_schema_dictionary_handler'
+
+module SpeckleConnector3
+  module Actions
+    # Clear mappings for selected entities from mapped elements table.
+    class ClearMappingsFromTable < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, _resolve_id, data)
+        # Flat entities to clear mappings
+        flat_entities = SketchupModel::Query::Entity.flat_entities(state.sketchup_state.sketchup_model.entities)
+
+        # Collect entity ids to clear mappings
+        entity_ids = data.collect { |_, entities| entities['selectedElements'].collect { |e| e['entityId'] } }.flatten
+        # Store speckle state to update with mapped entities.
+        speckle_state = state.speckle_state
+        flat_entities.each do |entity|
+          next unless entity_ids.include?(entity.persistent_id.to_s)
+
+          SketchupModel::Dictionary::SpeckleSchemaDictionaryHandler.remove_dictionary(entity)
+          speckle_state = speckle_state.with_removed_mapped_entity(entity)
+        end
+
+        new_state = MappedEntitiesUpdated.update_state(state.with_speckle_state(speckle_state))
+        Events::SelectionEventAction.update_state(new_state, { clear: true })
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/clear_queue.rb

@@ -2,7 +2,7 @@
 
 require_relative 'action'
 
-module SpeckleConnector
+module SpeckleConnector3
   module Actions
     # Clear queue from state.
     class ClearQueue < Action

speckle_connector_3/src/actions/collect_preferences.rb

@@ -4,13 +4,13 @@ require_relative 'action'
 require_relative '../ext/sqlite3'
 require_relative '../constants/path_constants'
 
-module SpeckleConnector
+module SpeckleConnector3
   module Actions
     # Action to collect preferences from database to UI.
     class CollectPreferences < Action
       # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
       # @return [States::State] the new updated state object
-      def self.update_state(state, _data)
+      def self.update_state(state, _resolve_id, _data)
         state.with_add_queue('collectPreferences', state.user_state.preferences.to_json, [])
       end
     end

speckle_connector_3/src/actions/collect_versions.rb

@@ -2,16 +2,16 @@
 
 require_relative 'action'
 
-module SpeckleConnector
+module SpeckleConnector3
   module Actions
     # Action to collect versions from sketchup and connector to track user's version by mixpanel.
     class CollectVersions < Action
       # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
       # @return [States::State] the new updated state object
-      def self.update_state(state, _data)
+      def self.update_state(state, _resolve_id, _data)
         versions = {
           sketchup: Sketchup.version.to_i,
-          speckle: SpeckleConnector::CONNECTOR_VERSION
+          speckle: SpeckleConnector3::CONNECTOR_VERSION
         }
         state.with_add_queue('collectVersions', versions.to_json, [])
       end

speckle_connector_3/src/actions/config_actions/get_config.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../action'
+
+module SpeckleConnector3
+  module Actions
+    # Action to get config.
+    class GetConfig < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, resolve_id)
+        # Previously it was stored in user state
+        # config = state.user_state.preferences.to_json
+        config = {
+          darkTheme: state.user_state.user_preferences[:dark_theme]
+        }
+        js_script = "configBinding.receiveResponse('#{resolve_id}', #{config.to_json})"
+        state.with_add_queue_js_command('getConfig', js_script)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/config_actions/get_is_dev_mode.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../action'
+
+module SpeckleConnector3
+  module Actions
+    # Action to get is dev mode.
+    class GetIsDevMode < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, resolve_id)
+        js_script = "configBinding.receiveResponse('#{resolve_id}', #{DEV_MODE})"
+        state.with_add_queue_js_command('getIsDevMode', js_script)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/config_actions/update_config.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../action'
+require_relative '../user_preferences_updated'
+
+module SpeckleConnector3
+  module Actions
+    # Action to update config.
+    class UpdateConfig < Action
+      KEY_VALUES = {
+        'darkTheme' => 'dark_theme'
+      }.freeze
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, resolve_id, config)
+        config.each do |key, value|
+          state = Actions::UserPreferencesUpdated.new('Sketchup', KEY_VALUES[key], value).update_state(state)
+        end
+
+        js_script = "configBinding.receiveResponse('#{resolve_id}')"
+        state.with_add_queue_js_command('updateConfig', js_script)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/connected.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module SpeckleConnector
+module SpeckleConnector3
   module Actions
     # Action to update connected state of application.
     class Connected < Action

speckle_connector_3/src/actions/create_stream.rb

@@ -6,7 +6,7 @@ require_relative '../actions/save_stream'
 require_relative '../actions/queue_send'
 require_relative '../convertors/converter'
 
-module SpeckleConnector
+module SpeckleConnector3
   module Actions
     # Create stream.
     class CreateStream < Action

speckle_connector_3/src/actions/deactivate_diffing.rb

@@ -2,13 +2,13 @@
 
 require_relative 'action'
 
-module SpeckleConnector
+module SpeckleConnector3
   module Actions
     # Deactivate diffing.
     class DeactivateDiffing < Action
       # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
       # @return [States::State] the new updated state object
-      def self.update_state(state, _data)
+      def self.update_state(state, _resolve_id, _data)
         puts 'Diffing deactivated!'
         speckle_entities = state.speckle_state.speckle_entities
         diffing_activated_speckle_entities = speckle_entities.reject do |_id, entity|

speckle_connector_3/src/actions/events/app_event_action.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 require_relative 'event_action'
+require_relative 'on_document_changed'
 require_relative '../load_sketchup_model'
 require_relative '../collect_preferences'
 
-module SpeckleConnector
+module SpeckleConnector3
   module Actions
     module Events
       # Handle events that are triggered by the {AppObserver}.
@@ -25,7 +26,8 @@ module SpeckleConnector
             # Action to let UI to render itself with new preferences state
             # TODO: Later UI should be updated if any stream is invalid after
             #  we collected speckle_entities appropriately
-            CollectPreferences.update_state(new_state, {})
+            new_state = CollectPreferences.update_state(new_state, nil, {})
+            OnDocumentChanged.update_state(new_state)
           end
         end
 

speckle_connector_3/src/actions/events/entities_event_action.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require_relative 'event_action'
+require_relative '../../actions/send_actions/send_card_expiration_check'
+require_relative '../../sketchup_model/utils/face_utils'
+require_relative '../../constants/dict_constants'
+require_relative '../../sketchup_model/query/path'
+
+module SpeckleConnector3
+  module Actions
+    module Events
+      # Event actions related to entities.
+      class EntitiesEventAction < EventAction
+        PATH = SketchupModel::Query::Path
+        # Event action when element added.
+        class OnElementAdded
+          # @param state [States::State] the current state of the SpeckleConnector Application
+          def self.update_state(state, event_data)
+            modified_entities = event_data.to_a.collect { |e| e[1] }
+            # do not copy speckle base object specific attributes, because they are entity specific
+            modified_entities.each { |entity| entity.delete_attribute(SPECKLE_BASE_OBJECT) }
+
+            # All parent ids on current active path
+            parent_ids = PATH.parents_with_definitions(state.sketchup_state.sketchup_model).collect(&:persistent_id).collect(&:to_s)
+
+            # All instances that changed potentially because of potential definition update
+            path_instance_ids = PATH.instances(state.sketchup_state.sketchup_model).collect(&:persistent_id).collect(&:to_s)
+            wrapped_entity_ids = wrapped_entity_ids(modified_entities)
+            ids_to_check = parent_ids + wrapped_entity_ids + path_instance_ids +
+              modified_entities.collect(&:persistent_id).collect(&:to_s) # NOTE: It fixes the same weird face problems. Ideally the push-pull result should hit the OnElementModified but for some cases we found the edge here......
+            state = EntitiesEventAction.run_expiration_checks(state, ids_to_check) if ids_to_check.any?
+
+            attach_edge_entity_observer(modified_entities.grep(Sketchup::Edge), state.speckle_state.observers[ENTITY_OBSERVER])
+            state
+          end
+
+          def self.wrapped_entity_ids(modified_entities)
+            wrapped_entity_ids = []
+            modified_entities.select { |e| e.respond_to?(:definition) }.each do |c|
+              wrapped_entity_ids += c.definition.entities.collect(&:persistent_id).collect(&:to_s)
+            end
+            wrapped_entity_ids
+          end
+
+          # It is needed for attaching EntityObserver to newly added edges to track them with a hacky way.
+          # This hacky way is because of limitation on Sketchup API that observer cannot catch changes on Edges
+          # with EntitiesObserver.
+          def self.attach_edge_entity_observer(edges, observer)
+            edges.each do |edge|
+              edge.add_observer(observer)
+              edge.start.add_observer(observer)
+              edge.end.add_observer(observer)
+            end
+          end
+        end
+
+        # Event action when element modified.
+        class OnElementModified
+          # @param state [States::State] the current state of the SpeckleConnector Application
+          def self.update_state(state, event_data)
+            modified_entities = event_data.collect { |data| data[1] }.to_a
+            definition_faces = get_definition_faces(modified_entities)
+            near_faces = get_near_faces(modified_entities)
+            modified_persistent_ids = modified_entities.collect(&:persistent_id).collect(&:to_s) +
+              definition_faces.collect(&:persistent_id).collect(&:to_s) +
+              near_faces.collect(&:persistent_id).collect(&:to_s)
+
+            parent_ids = PATH.parents_with_definitions(state.sketchup_state.sketchup_model).collect(&:persistent_id).collect(&:to_s)
+
+            path_instance_ids = PATH.instances(state.sketchup_state.sketchup_model).collect(&:persistent_id).collect(&:to_s)
+            modified_persistent_ids += parent_ids + path_instance_ids
+            state = EntitiesEventAction.run_expiration_checks(state, modified_persistent_ids)
+            # if modified_entity.is_a?(Sketchup::Face)
+            #   path = state.sketchup_state.sketchup_model.active_path
+            #   modified_faces = SketchupModel::Utils::FaceUtils.near_faces(modified_entity.edges)
+            #   path_objects = path.nil? ? [] : path + path.collect(&:definition)
+            #   parent_ids = path_objects.collect(&:persistent_id).collect(&:to_s)
+            #   ids_to_invalidate = modified_faces.collect(&:persistent_id).collect(&:to_s) + parent_ids
+            #   entities_to_invalidate = speckle_entities_to_invalidate(speckle_state, ids_to_invalidate)
+            #   new_speckle_state = invalidate_speckle_entities(speckle_state, entities_to_invalidate)
+            #   # This is the place we can send information to UI for diffing check
+            #   diffing = state.user_state.preferences[:user][:diffing]
+            #   new_speckle_state = new_speckle_state.with_invalid_streams_queue if diffing
+            #   return state.with_speckle_state(new_speckle_state)
+            # end
+
+            state
+          end
+
+          def self.get_near_faces(modified_entities)
+            near_faces = []
+            modified_entities.each do |modified_entity|
+              if modified_entity.is_a?(Sketchup::Face)
+                near_faces += SketchupModel::Utils::FaceUtils.near_faces(modified_entity.edges)
+              elsif modified_entity.is_a?(Sketchup::Edge)
+                near_faces += modified_entity.faces
+              end
+            end
+            near_faces
+          end
+
+          def self.get_definition_faces(modified_entities)
+            definition_faces = []
+            modified_entities.each do |modified_entity|
+              next unless modified_entity.is_a?(Sketchup::Face)
+              next unless modified_entity.parent.is_a?(Sketchup::ComponentDefinition)
+
+              definition_faces += modified_entity.parent.entities.grep(Sketchup::Face)
+            end
+            definition_faces
+          end
+
+          # @param speckle_state [States::SpeckleState] the current state of the Speckle
+          def self.speckle_entities_to_invalidate(speckle_state, ids)
+            speckle_state.speckle_entities.to_h.select { |id, _| ids.include?(id) }
+          end
+
+          # @param speckle_state [States::SpeckleState] the current state of the Speckle
+          def self.invalidate_speckle_entities(speckle_state, entities_to_invalidate)
+            speckle_entities = speckle_state.speckle_entities
+            entities_to_invalidate.each do |id, speckle_entity|
+              edited_speckle_entity = speckle_entity.with_invalid
+              speckle_entities = speckle_entities.put(id, edited_speckle_entity)
+            end
+            speckle_state.with_speckle_entities(speckle_entities)
+          end
+        end
+
+        # Event action when element removed.
+        class OnElementRemoved
+          # @param state [States::State] the current state of the SpeckleConnector Application
+          def self.update_state(state, event_data)
+            modified_entity_ids = event_data.collect { |data| data[1] }.to_a.collect(&:to_s)
+            new_speckle_state = state.speckle_state.with_changed_entity_ids(modified_entity_ids)
+            state = state.with_speckle_state(new_speckle_state)
+            Actions::SendCardExpirationCheck.update_state(state)
+          end
+        end
+
+        # @param state [States::State] the current state of the SpeckleConnector Application
+        # @param changed_persistent_ids [Array<String>] list of changed persistent ids
+        def self.run_expiration_checks(state, changed_persistent_ids)
+          new_speckle_state = state.speckle_state.with_changed_entity_persistent_ids(changed_persistent_ids)
+          state = state.with_speckle_state(new_speckle_state)
+          Actions::SendCardExpirationCheck.update_state(state)
+        end
+
+        # Handlers that are used to handle specific events
+        ACTIONS = {
+          onElementRemoved: OnElementRemoved,
+          onElementAdded: OnElementAdded,
+          onElementModified: OnElementModified
+        }.freeze
+
+        def self.actions
+          ACTIONS
+        end
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/events/entity_event_action.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'event_action'
+require_relative '../../constants/dict_constants'
+require_relative '../../sketchup_model/query/path'
+
+module SpeckleConnector3
+  module Actions
+    module Events
+      PATH = SketchupModel::Query::Path
+      # Event actions related to entities.
+      class EntityEventAction < EventAction
+        # Event action when entity modified/changed.
+        # PS: this handler action only triggers for edges and it's vertices since we attach EntityObserver to
+        # only edge and vertex entities. This is a limitation of the Sketchup API that can't handles edges with
+        # EntitiesObserver.
+        class OnChangeEntity
+          # @param state [States::State] the current state of the SpeckleConnector Application
+          def self.update_state(state, event_data)
+            edges = []
+            event_data.each do |event_d|
+              event_d.each do |d|
+                next if d.deleted?
+
+                edges.append(d) if d.is_a?(Sketchup::Edge)
+                edges += d.edges if d.is_a?(Sketchup::Vertex) && d.edges
+              end
+            end
+
+            parent_ids = PATH.parents_with_definitions(state.sketchup_state.sketchup_model).collect(&:persistent_id).collect(&:to_s)
+            path_instance_ids = PATH.instances(state.sketchup_state.sketchup_model).collect(&:persistent_id).collect(&:to_s)
+
+            edges.uniq!
+            edge_ids = edges.collect(&:persistent_id).collect(&:to_s)
+            new_speckle_state = state.speckle_state.with_changed_entity_persistent_ids(edge_ids + parent_ids + path_instance_ids)
+            state.with_speckle_state(new_speckle_state)
+          end
+        end
+
+        # Handlers that are used to handle specific events
+        ACTIONS = {
+          onChangeEntity: OnChangeEntity
+        }.freeze
+
+        def self.actions
+          ACTIONS
+        end
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/events/event_action.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module SpeckleConnector
+module SpeckleConnector3
   module Actions
     # This module contains actions that are performed to handle events triggered by observers in Sketchup.
     module Events

speckle_connector_3/src/actions/events/model_event_action.rb

@@ -3,7 +3,7 @@
 require_relative 'event_action'
 require_relative '../load_sketchup_model'
 
-module SpeckleConnector
+module SpeckleConnector3
   module Actions
     module Events
       # Handle events that are triggered by the {ModelObserver}.
@@ -18,12 +18,21 @@ module SpeckleConnector
             sketchup_state = state.sketchup_state
             active_path = sketchup_state.sketchup_model.active_path
             observers = state.speckle_state.observers
-            update_object_observers(active_path, observers)
+            update_entity_observers(active_path, observers)
             return state
           end
 
-          def self.update_object_observers(path, observers)
-            path[-1].definition.entities.add_observer(observers[ENTITIES_OBSERVER]) unless path.nil?
+          def self.update_entity_observers(path, observers)
+            unless path.nil?
+              new_path_entities = path[-1].definition.entities
+              new_path_entities.add_observer(observers[ENTITIES_OBSERVER])
+              edges = new_path_entities.grep(Sketchup::Edge)
+              edges.each do |edge|
+                edge.add_observer(observers[ENTITY_OBSERVER])
+                edge.start.add_observer(observers[ENTITY_OBSERVER])
+                edge.end.add_observer(observers[ENTITY_OBSERVER])
+              end
+            end
           end
         end
 

speckle_connector_3/src/actions/events/on_document_changed.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module SpeckleConnector3
+  module Actions
+    # Triggers whenever document has changed.
+    class OnDocumentChanged < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state)
+        js_command = "baseBinding.emit('documentChanged')"
+        state.with_add_queue_js_command('documentChanged', js_command)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/events/selection_event_action.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'event_action'
+require_relative '../mapper_selection_changed'
+require_relative '../selection_actions/get_selection'
+require_relative '../../mapper/category/revit_category'
+require_relative '../../sketchup_model/reader/speckle_entities_reader'
+require_relative '../../sketchup_model/reader/mapper_reader'
+require_relative '../../sketchup_model/query/entity'
+
+module SpeckleConnector3
+  module Actions
+    module Events
+      # Update selected speckle objects when the selection changes for mapper tool.
+      class SelectionEventAction < EventAction
+        # @param state [States::State] the current state of Speckle application.
+        # @return [States::State] the new updated state object
+        def self.update_state(state, event_data)
+          return state unless event_data&.any?
+
+          # POC: Not happy with it. We log also entity.entityID property since
+          # onElementRemoved observer only return them! :/ Reconsider this in BETA!
+          selected_object_ids = state.sketchup_state.sketchup_model.selection.collect(&:persistent_id).collect(&:to_s) +
+                                state.sketchup_state.sketchup_model.selection.collect(&:entityID).collect(&:to_s)
+          summary = "Selected #{selected_object_ids.length / 2} objects." # POC: OFFF. I'll fix it
+          selection_info = UiData::Sketchup::SelectionInfo.new(selected_object_ids, summary)
+          js_script = "selectionBinding.emit('setSelection', #{selection_info.to_json})"
+          state.with_add_queue_js_command('setSelection', js_script)
+
+          # Collect and return mapper selection info.
+          # Later we can add more selection info for different scopes.
+          # MapperSelectionChanged.new(sketchup_selection).update_state(state)
+        end
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/get_accounts.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../accounts/accounts'
+require_relative 'load_saved_streams'
+
+module SpeckleConnector3
+  module Actions
+    # Action to initialize local accounts from database.
+    class GetAccounts < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, resolve_id)
+        puts 'Initialisation of Speckle accounts requested by plugin'
+        accounts_data = state.speckle_state.accounts
+        js_script = "accountsBinding.receiveResponse('#{resolve_id}', #{accounts_data.to_json})"
+        state.with_add_queue_js_command('getAccounts', js_script)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/get_document_info.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+
+module SpeckleConnector3
+  module Actions
+    # Get document info.
+    class GetDocumentInfo < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, resolve_id)
+        document_info = {
+          location: state.sketchup_state.sketchup_model.path,
+          name: state.sketchup_state.sketchup_model.name,
+          id: state.sketchup_state.sketchup_model.guid
+        }
+        js_command = "baseBinding.receiveResponse('#{resolve_id}', #{document_info.to_json})"
+        state.with_add_queue_js_command('getDocumentInfo', js_command)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/handle_error.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SpeckleConnector3
+  module Actions
+    # Action to return error message to UI.
+    # It is "TopLevelExceptionHandler" equivalent of C#.
+    class HandleError < Action
+      # @return [StandardError] error
+      attr_reader :error
+
+      # @param error [StandardError] error
+      # @param view_name [String] name of the view (binding)
+      # @param action [Action] action that error happened
+      # @param parameters [Array<String>] arguments
+      def initialize(error, view_name, action, parameters)
+        super()
+        @error = error
+        @view_name = view_name
+        @action = action
+        @args = parameters
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def update_state(state)
+        # TODO: Log here when it is ready!!!
+        host_app_error = {
+          message: error.message,
+          error: error,
+          stackTrace: error.backtrace
+        }
+        js_error_script = "#{@view_name}.receiveResponse('#{@args.first}', #{host_app_error.to_json})"
+        state.with_add_queue_js_command("error_#{@view_name}", js_error_script)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/hide_mappings_from_table.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative 'events/selection_event_action'
+require_relative '../sketchup_model/dictionary/speckle_schema_dictionary_handler'
+
+module SpeckleConnector3
+  module Actions
+    # Hide entities that selected from mapped elements table.
+    class HideMappingsFromTable < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, _resolve_id, data)
+        # Flat entities to clear mappings
+        flat_entities = SketchupModel::Query::Entity.flat_entities(state.sketchup_state.sketchup_model.entities)
+
+        # Collect entity ids to clear mappings
+        entity_ids = data.collect { |_, entities| entities['selectedElements'].collect { |e| e['entityId'] } }.flatten
+
+        # Store speckle state to update with mapped entities.
+        flat_entities.each do |entity|
+          next unless entity_ids.include?(entity.persistent_id.to_s)
+
+          if entity.is_a?(Sketchup::ComponentDefinition)
+            entity.instances.each do |instance|
+              instance.hidden = true
+            end
+          end
+          entity.hidden = true
+        end
+
+        Events::SelectionEventAction.update_state(state, { clear: true })
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/init_local_accounts.rb

@@ -4,13 +4,13 @@ require_relative 'action'
 require_relative '../accounts/accounts'
 require_relative 'load_saved_streams'
 
-module SpeckleConnector
+module SpeckleConnector3
   module Actions
     # Action to initialize local accounts from database.
     class InitLocalAccounts < Action
       # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
       # @return [States::State] the new updated state object
-      def self.update_state(state, _data)
+      def self.update_state(state, _request_id, _data)
         puts 'Initialisation of Speckle accounts requested by plugin'
         accounts_data = state.speckle_state.accounts
         state.with_add_queue('loadAccounts', accounts_data.to_json, [])

speckle_connector_3/src/actions/initialize_materials.rb

@@ -4,7 +4,7 @@ require_relative 'action'
 require_relative 'add_material'
 require_relative '../constants/mat_constants'
 
-module SpeckleConnector
+module SpeckleConnector3
   module Actions
     # Action to initialize materials
     class InitializeMaterials < Action

speckle_connector_3/src/actions/initialize_speckle.rb

@@ -7,22 +7,26 @@ require_relative '../states/sketchup_state'
 require_relative '../accounts/accounts'
 require_relative '../preferences/preferences'
 require_relative '../constants/observer_constants'
+require_relative '../ext/worker'
 
-module SpeckleConnector
+module SpeckleConnector3
   module Actions
     # Initialization of the real state of the speckle.
     class InitializeSpeckle < Action
       # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
       # @return [States::State] the new updated state object
-      def self.update_state(state, observers)
+      def self.update_state(state, observers, instant_message_sender)
+        worker = SpeckleConnector3::Worker.new([])
         attach_app_observer!(observers[APP_OBSERVER])
-        accounts = SpeckleConnector::Accounts.load_accounts
+        accounts = SpeckleConnector3::Accounts.load_accounts
         speckle_state = States::SpeckleState.new(accounts, observers, {}, {})
         # This should be the only point that `Sketchup_active_model` passed to application state.
         sketchup_state = States::SketchupState.new(Sketchup.active_model)
         preferences = Preferences.read_preferences(sketchup_state.sketchup_model)
         user_state_with_preferences = state.user_state.with_preferences(preferences)
-        state = States::State.new(user_state_with_preferences, speckle_state, sketchup_state, false)
+        state = States::State.new(user_state_with_preferences, speckle_state, sketchup_state, false,
+                                  worker, &instant_message_sender)
+        # This is where we attach observers to related model objects like selection, entities..
         Actions::LoadSketchupModel.update_state(state, sketchup_state.sketchup_model)
       end
 

speckle_connector_3/src/actions/isolate_mappings_from_table.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative 'events/selection_event_action'
+require_relative '../sketchup_model/dictionary/speckle_schema_dictionary_handler'
+
+module SpeckleConnector3
+  module Actions
+    # Isolate entities that selected from mapped elements table.
+    class IsolateMappingsFromTable < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def self.update_state(state, _resolve_id, data)
+        sketchup_model = state.sketchup_state.sketchup_model
+
+        # Hide all entities first
+        sketchup_model.entities.each do |ent|
+          ent.hidden = true
+        end
+
+        # Flat entities to isolate mappings
+        flat_entities = SketchupModel::Query::Entity.flat_entities(sketchup_model.entities)
+
+        comp_flat_entities = flat_entities.grep(Sketchup::ComponentInstance) + flat_entities.grep(Sketchup::Group) +
+                             flat_entities.grep(Sketchup::ComponentDefinition)
+        face_edge_flat_entities = flat_entities.grep(Sketchup::Face) + flat_entities.grep(Sketchup::Edge)
+
+        # Collect entity ids to clear mappings
+        selected_elements = data.collect { |_, entities| entities['selectedElements'] }.flatten
+
+        comps_or_groups, faces_or_edges = selected_elements.partition do |e|
+          e['entityType'] == 'Component' || e['entityType'] == 'Definition' || e['entityType'] == 'Group'
+        end
+
+        faces_or_edges_ids = faces_or_edges.collect { |e| e['entityId'] }
+
+        face_edge_flat_entities.select { |e| faces_or_edges_ids.include?(e.persistent_id.to_s) }.each do |entity|
+          entity.hidden = false
+        end
+
+        comps_or_groups_ids = comps_or_groups.collect { |e| e['entityId'] }
+
+        comp_flat_entities.select { |e| comps_or_groups_ids.include?(e.persistent_id.to_s) }.each do |entity|
+          if entity.is_a?(Sketchup::ComponentDefinition)
+            entity.instances.each do |instance|
+              instance.hidden = false
+            end
+          end
+          entity.hidden = false
+        end
+
+        Events::SelectionEventAction.update_state(state, { clear: true })
+      end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/CyclomaticComplexity
+    end
+  end
+end

speckle_connector_3/src/actions/load_saved_streams.rb

@@ -2,13 +2,13 @@
 
 require_relative 'action'
 
-module SpeckleConnector
+module SpeckleConnector3
   module Actions
     # Action to load saved streams.
     class LoadSavedStreams < Action
       # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
       # @return [States::State] the new updated state object
-      def self.update_state(state, _data)
+      def self.update_state(state, _request_id, _data)
         (saved_streams = state.sketchup_state.sketchup_model
                               .attribute_dictionary('Speckle', true)['saved_streams']) or []
         state.with_add_queue('setSavedStreams', saved_streams, [])

speckle_connector_3/src/actions/load_sketchup_model.rb

@@ -3,12 +3,13 @@
 require_relative 'action'
 require_relative 'initialize_materials'
 require_relative '../sketchup_model/reader/speckle_entities_reader'
+require_relative '../sketchup_model/reader/mapper_reader'
 require_relative '../preferences/preferences'
 require_relative '../states/state'
 require_relative '../states/sketchup_state'
 require_relative '../constants/observer_constants'
 
-module SpeckleConnector
+module SpeckleConnector3
   module Actions
     # Switch sketchup model wit a new one
     class LoadSketchupModel < Action
@@ -28,6 +29,11 @@ module SpeckleConnector
         # Read speckle entities
         new_speckle_entities = SketchupModel::Reader::SpeckleEntitiesReader.read(sketchup_model.entities)
         new_speckle_state = new_state.speckle_state.with_speckle_entities(Immutable::Hash.new(new_speckle_entities))
+        # POC: Reconsider it when we will do caching between sessions!
+        new_speckle_state = new_speckle_state.with_empty_object_references
+        # Read mapped entities
+        new_mapped_entities = SketchupModel::Reader::MapperReader.read_mapped_entities(sketchup_model.entities)
+        new_speckle_state = new_speckle_state.with_mapped_entities(Immutable::Hash.new(new_mapped_entities))
         new_state = new_state.with_speckle_state(new_speckle_state)
 
         # Read preferences from database and model.
@@ -42,11 +48,13 @@ module SpeckleConnector
       # @param sketchup_model [Sketchup::Model] the model to attach observers to
       # @param observers [Hash{Class=>}] the observer objects indexed by their class that will be attached
       def self.attach_observers(sketchup_model, observers)
-        # selection = sketchup_model.selection
-        # selection.add_observer(observers[SELECTION_OBSERVER_NAME])
+        selection = sketchup_model.selection
+        selection.add_observer(observers[SELECTION_OBSERVER])
         # layers = sketchup_model.layers
         # layers.add_observer(observers[LAYERS_OBSERVER_NAME])
         entities = sketchup_model.entities
+        edges = entities.grep(Sketchup::Edge)
+        edges.each { |edge| edge.add_observer(observers[ENTITY_OBSERVER]) }
         entities.add_observer(observers[ENTITIES_OBSERVER])
         sketchup_model.add_observer(observers[MODEL_OBSERVER])
         # materials = sketchup_model.materials

speckle_connector_3/src/actions/mapped_entities_updated.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../sketchup_model/reader/mapper_reader'
+
+module SpeckleConnector3
+  module Actions
+    # Triggers when mapped entities updated.
+    class MappedEntitiesUpdated < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, _resolve_id = nil, _data = nil)
+        mapped_entities = SketchupModel::Reader::MapperReader
+                          .mapped_entity_details(state.speckle_state.speckle_mapper_state.mapped_entities.values.to_a)
+
+        state.with_mapped_entities_queue(mapped_entities)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/mapper_initialized.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../mapper/category/revit_category'
+require_relative '../mapper/category/revit_family_category'
+
+module SpeckleConnector3
+  module Actions
+    # Collects mapper selection info.
+    class MapperInitialized < Action
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def self.update_state(state, _data)
+        init_parameters = {
+          categories: Mapper::Category::RevitCategory.to_a,
+          familyCategories: Mapper::Category::RevitFamilyCategory.to_a
+        }.freeze
+        state.with_mapper_init_queue(init_parameters)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/mapper_selection_changed.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../mapper/category/revit_category'
+require_relative '../mapper/category/revit_family_category'
+require_relative '../sketchup_model/reader/mapper_reader'
+require_relative '../sketchup_model/reader/speckle_entities_reader'
+require_relative '../sketchup_model/dictionary/speckle_entity_dictionary_handler'
+
+module SpeckleConnector3
+  module Actions
+    # Collects mapper selection info.
+    class MapperSelectionChanged < Action
+      READER = SketchupModel::Reader
+      DICTIONARY = SketchupModel::Dictionary
+
+      def initialize(selection)
+        super()
+        @selection = selection
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def update_state(state)
+        # Get mapping info from selection.
+        mapping = get_mapping_info(state, @selection)
+
+        state.with_mapper_selection_queue(mapping)
+      end
+
+      def filter_out_levels(selection)
+        selection.reject do |e|
+          DICTIONARY::SpeckleEntityDictionaryHandler
+            .get_attribute(e, :speckle_type) == OBJECTS_BUILTELEMENTS_REVIT_LEVEL
+        end
+      end
+
+      def get_mapping_info(state, selection)
+        source_exist = !state.speckle_state.speckle_mapper_state.mapper_source.nil?
+        selection = filter_out_levels(selection)
+        grouped_by_type = group_by_type(selection)
+
+        supported_entity_count = grouped_by_type.length
+
+        # Return empty method list if there is no supported entity to map.
+        return EMPTY_SELECTION if supported_entity_count == 0
+
+        # Return Direct Shape itself if multiple kinds of element are selected like Edge and Face.
+        # OR single type is equal to only direct shape supports.
+        return multiple_supported_selection_info(selection) if supported_entity_count > 1
+
+        # FIXME: Distinguish selection info according to selection elegantly!!!
+        if grouped_by_type.keys.first == Sketchup::ComponentInstance
+          return component_selection_info(selection, source_exist)
+        end
+
+        return group_selection_info(selection) if grouped_by_type.keys.first == Sketchup::Group
+
+        if supported_entity_count > 1 ||
+           (supported_entity_count == 1 &&
+             MAPPER_DIRECT_SHAPE_SUPPORTED_ENTITY_TYPES.include?(grouped_by_type.keys.first))
+          if source_exist
+            return direct_shape_selection_info_with_source(selection, [])
+          else
+            return direct_shape_selection_info(selection, source_exist)
+          end
+        end
+
+        # Only single type selections remained after this point.
+        return face_selection_info(state, grouped_by_type.values.first) if grouped_by_type.keys.first == Sketchup::Face
+
+        return edge_selection_info(state, grouped_by_type.values.first) if grouped_by_type.keys.first == Sketchup::Edge
+
+        EMPTY_SELECTION
+      end
+
+      MAPPER_SUPPORTED_ENTITY_TYPES = [
+        Sketchup::ComponentInstance,
+        Sketchup::Group,
+        Sketchup::Face,
+        Sketchup::Edge
+      ].freeze
+
+      MAPPER_DIRECT_SHAPE_SUPPORTED_ENTITY_TYPES = [
+        Sketchup::ComponentInstance,
+        Sketchup::Group
+      ].freeze
+
+      EMPTY_SELECTION = {
+        selection: [],
+        mappingMethods: []
+      }.freeze
+
+      def multiple_supported_selection_info(selection)
+        {
+          selection: SketchupModel::Reader::MapperReader.entities_schema_details(selection),
+          mappingMethods: ['Direct Shape']
+        }.freeze
+      end
+
+      def component_selection_info(selection, source_exist)
+        if source_exist
+          {
+            selection: SketchupModel::Reader::MapperReader.entities_schema_details(selection),
+            mappingMethods: ['Direct Shape', 'New Revit Family', 'Family Instance']
+          }.freeze
+        else
+          {
+            selection: SketchupModel::Reader::MapperReader.entities_schema_details(selection),
+            mappingMethods: ['Direct Shape', 'New Revit Family']
+          }.freeze
+        end
+      end
+
+      def group_selection_info(selection)
+        {
+          selection: SketchupModel::Reader::MapperReader.entities_schema_details(selection),
+          mappingMethods: ['Direct Shape']
+        }.freeze
+      end
+
+      def direct_shape_selection_info(selection, source_exist)
+        methods = ['Direct Shape', 'New Revit Family']
+        methods.append('Family Instance') if source_exist
+        {
+          selection: SketchupModel::Reader::MapperReader.entities_schema_details(selection),
+          mappingMethods: methods
+        }.freeze
+      end
+
+      def direct_shape_selection_info_with_default(selection, methods)
+        {
+          selection: SketchupModel::Reader::MapperReader.entities_schema_details(selection),
+          mappingMethods: ['Direct Shape'] + methods
+        }.freeze
+      end
+
+      def direct_shape_selection_info_with_source(filtered_selection, methods)
+        instances = @selection.grep(Sketchup::ComponentInstance)
+        selected_level = instances.find do |i|
+          DICTIONARY::SpeckleEntityDictionaryHandler
+            .get_attribute(i, :speckle_type) == OBJECTS_BUILTELEMENTS_REVIT_LEVEL
+        end
+        selected_level_name = nil
+        if selected_level
+          selected_level_name = DICTIONARY::SpeckleEntityDictionaryHandler.get_attribute(selected_level, :name)
+        end
+        {
+          selection: READER::MapperReader.entities_schema_details(filtered_selection),
+          mappingMethods: ['Direct Shape'] + methods,
+          categories: Mapper::Category::RevitCategory.to_a,
+          selectedLevelName: selected_level_name
+        }.freeze
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      def face_selection_info(state, faces)
+        source_exist = !state.speckle_state.speckle_mapper_state.mapper_source.nil?
+        grouped_by_verticality = faces.group_by { |face| face.normal.perpendicular?(VECTOR_Z) }
+        return direct_shape_selection_info(faces, source_exist) if grouped_by_verticality.length == 2
+
+        if source_exist
+          if grouped_by_verticality.keys.first
+            direct_shape_selection_info_with_source(faces, ['Wall'])
+          else
+            direct_shape_selection_info_with_source(faces, ['Floor'])
+          end
+        else
+          if grouped_by_verticality.keys.first
+            direct_shape_selection_info_with_default(faces, ['Default Wall'])
+          else
+            direct_shape_selection_info_with_default(faces, ['Default Floor'])
+          end
+        end
+      end
+
+      def edge_selection_info(state, edges)
+        source_exist = !state.speckle_state.speckle_mapper_state.mapper_source.nil?
+
+        if source_exist
+          methods = ['Column', 'Beam', 'Pipe', 'Duct']
+          direct_shape_selection_info_with_source(edges, methods)
+        else
+          default_methods = ['Default Column', 'Default Beam', 'Default Pipe', 'Default Duct']
+          direct_shape_selection_info_with_default(edges, default_methods)
+        end
+      end
+
+      def group_by_type_old(selection)
+        selection.group_by(&:class).filter_map do |group|
+          [group.first, group] if MAPPER_SUPPORTED_ENTITY_TYPES.include?(group.first)
+        end.to_h
+      end
+
+      def group_by_type(selection)
+        selection.select { |s| MAPPER_SUPPORTED_ENTITY_TYPES.include?(s.class) }.group_by(&:class)
+      end
+    end
+  end
+end

speckle_connector_3/src/actions/mapper_source_updated.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative 'action'
+require_relative '../constants/type_constants'
+require_relative '../mapper/mapper_source'
+require_relative '../speckle_objects/built_elements/revit/revit_element_type'
+
+module SpeckleConnector3
+  module Actions
+    # Action to update mapper source.
+    class MapperSourceUpdated < Action
+      def initialize(base, stream_id, commit_id)
+        super()
+        @base = base
+        @stream_id = stream_id
+        @commit_id = commit_id
+      end
+
+      # @param state [States::State] the current state of the {App::SpeckleConnectorApp}
+      # @return [States::State] the new updated state object
+      def update_state(state)
+        levels = convert_levels(state, @base['@Levels'])
+        types = convert_types(@base['@Types'])
+        family_instances = convert_family_instance_types(@base['@Types'])
+        mapper_source = Mapper::MapperSource.new(@stream_id, @commit_id, levels, types)
+        new_speckle_state = state.speckle_state.with_mapper_source(mapper_source)
+        state = state.with_speckle_state(new_speckle_state)
+
+        state.with_add_queue('mapperSourceUpdated', @stream_id, [
+                               { is_string: false, val: levels.to_json },
+                               { is_string: false, val: types.to_json },
+                               { is_string: false, val: family_instances.to_json }
+                             ])
+      end
+
+      def convert_types(types)
+        types.collect do |type, type_elements|
+          next if type_elements.nil? || !type_elements.is_a?(Array) || type == '__closure'
+
+          type = type[1..-1] if type[0] == '@'
+          elements = type_elements.map do |type_element|
+            SpeckleObjects::BuiltElements::Revit::RevitElementType.to_native(type_element)
+          end
+          elements = elements.group_by { |e| e[:family] }
+          [type, elements]
+        end.compact.to_h
+      end
+
+      def convert_family_instance_types(types)
+        family_instance_types = {}
+        types.each do |type, type_elements|
+          next if type_elements.nil? || !type_elements.is_a?(Array) || type == '__closure'
+
+          # skip type if there is no any revit symbol element type
+          symbol_element_types = type_elements.select do |t|
+            t['speckle_type'] == OBJECTS_BUILTELEMENTS_REVIT_REVITSYMBOLELEMENTTYPE &&
+              t['placementType'] == 'OneLevelBased'
+          end
+          next if symbol_element_types.empty?
+
+          elements = type_elements.map do |type_element|
+            SpeckleObjects::BuiltElements::Revit::RevitElementType.to_native(type_element)
+          end
+          elements = elements.group_by { |e| e[:family] }
+          family_instance_types.merge!(elements)
+        end
+        family_instance_types
+      end
+
+      def convert_levels(state, levels)
+        levels.collect do |level|
+          SpeckleObjects::BuiltElements::Level.to_native(state, level, @stream_id)
+        end
+      end
+    end
+  end
+end