mxrb 0.1.3 → 0.1.4

data/lib/mxrb/scaffold/generator.rb

@@ -157,15 +157,23 @@ module Mxrb
         @transaction.write(path, lines.join)
       end
 
-      def connect_project_dotenv(source)
+      def connect_project_dotenv(source) # rubocop:disable Metrics/MethodLength
+        return source if source.include?('Mxrb::Environment.load(root: __dir__).apply')
+
         dotenv_line = 'Dotenv.load(File.join(__dir__, ".env"))'
         return source if source.include?(dotenv_line)
 
         lines = source.lines
         require_line = lines.index { _1.match?(%r{^require ["']dotenv/load["']\s*$}) }
-        raise ArgumentError, 'project.rb must require dotenv/load before scaffolding demo users' unless require_line
+        return lines.insert(require_line + 1, "#{dotenv_line}\n").join if require_line
+
+        mxrb_require = lines.index { _1.match?(/^require ["']mxrb["']\s*$/) }
+        unless mxrb_require
+          raise ArgumentError,
+                'project.rb must require mxrb or dotenv/load before scaffolding demo users'
+        end
 
-        lines.insert(require_line + 1, "#{dotenv_line}\n").join
+        lines.insert(mxrb_require + 1, "\nMxrb::Environment.load(root: __dir__).apply\n").join
       end
 
       def security_initialization_error

data/lib/mxrb/uml/activity_diagram.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative 'support'
+
+module Mxrb
+  module Uml
+    # Renders the native object/sequence-flow graph of one Mendix microflow.
+    # rubocop:disable Metrics
+    class ActivityDiagram
+      def initialize(microflow)
+        @microflow = microflow
+        @objects = Array(microflow.objects)
+        @flows = Array(microflow.flows)
+        @objects_by_id = @objects.to_h { [raw_object_id(_1), _1] }
+      end
+
+      def to_mermaid
+        lines = ['flowchart TD']
+        @objects.each { lines << "  #{mermaid_node(_1)}" }
+        @flows.each do |flow|
+          line = flow_line(flow, :mermaid)
+          lines << "  #{line}" if line
+        end
+        "#{lines.join("\n")}\n"
+      end
+
+      def to_plantuml
+        lines = ['@startuml', "title #{Support.plantuml_text(@microflow.name)}"]
+        @objects.each { lines << plantuml_node(_1) }
+        @flows.each do |flow|
+          line = flow_line(flow, :plantuml)
+          lines << line if line
+        end
+        lines << '@enduml'
+        "#{lines.join("\n")}\n"
+      end
+
+      private
+
+      def mermaid_node(object)
+        id = node_id(object)
+        label = Support.mermaid_text(object_label(object))
+        case object_type(object)
+        when 'StartEvent' then %(#{id}(["Start"]))
+        when 'EndEvent', 'ErrorEvent', 'ContinueEvent' then %(#{id}(["#{label}"]))
+        when 'DecisionMergeActivity', 'ExclusiveMerge' then %(#{id}{"#{label}"})
+        else %(#{id}["#{label}"])
+        end
+      end
+
+      def plantuml_node(object)
+        id = node_id(object)
+        label = Support.plantuml_text(object_label(object))
+        shape = %w[DecisionMergeActivity ExclusiveMerge].include?(object_type(object)) ? 'choice' : 'state'
+        %(#{shape} "#{label}" as #{id})
+      end
+
+      def flow_line(flow, format)
+        origin = pointer(flow, 'OriginPointer', 'Origin')
+        destination = pointer(flow, 'DestinationPointer', 'Destination')
+        return unless @objects_by_id.key?(origin) && @objects_by_id.key?(destination)
+
+        label = flow_label(flow)
+        if format == :mermaid
+          middle = label.empty? ? '-->' : %(-->|"#{Support.mermaid_text(label)}"|)
+          "#{node_id(@objects_by_id.fetch(origin))} #{middle} #{node_id(@objects_by_id.fetch(destination))}"
+        else
+          suffix = label.empty? ? '' : " : #{Support.plantuml_text(label)}"
+          "#{node_id(@objects_by_id.fetch(origin))} --> #{node_id(@objects_by_id.fetch(destination))}#{suffix}"
+        end
+      end
+
+      def object_label(object)
+        type = object_type(object)
+        return 'Start' if type == 'StartEvent'
+        return Support.words(type) unless type == 'ActionActivity'
+
+        caption = object['Caption'] || object['caption']
+        action = object['Action'] || object['action'] || {}
+        generated = object['AutoGenerateCaption'] == true || caption.to_s == 'Activity'
+        return caption unless caption.to_s.empty? || generated
+
+        call = action['MicroflowCall'] || action['microflowCall'] || {}
+        target = call['Microflow'] || call['microflow']
+        return "Call #{target}" unless target.to_s.empty?
+
+        Support.words(action['$Type'] || action['Type'] || 'Action')
+      end
+
+      def flow_label(flow)
+        direct = flow['Caption'] || flow['Label'] || flow['Condition']
+        return direct.to_s unless direct.to_s.empty?
+
+        value = flow['CaseValue'] || flow['caseValue']
+        value = Mxrb::IO::BsonCodec.parse_array(flow['CaseValues'])[:items].first if value.nil? && flow['CaseValues']
+        return '' if value.nil?
+
+        if value.is_a?(Hash)
+          return '' if (value['$Type'] || value['Type']).to_s.end_with?('$NoCase')
+
+          (value['StringRepresentation'] || value['Value'] || Support.words(value['$Type'])).to_s
+        else
+          value.to_s
+        end
+      end
+
+      def pointer(flow, *keys)
+        value = keys.filter_map { flow[_1] }.first
+        Mxrb::IO::BsonCodec.extract_id(value).to_s
+      end
+
+      def raw_object_id(object) = Mxrb::IO::BsonCodec.extract_id(object['$ID'] || object['ID']).to_s
+      def object_type(object) = (object['$Type'] || object['Type']).to_s.delete_prefix('Microflows$')
+      def node_id(object) = Support.identifier(raw_object_id(object), prefix: 'activity')
+    end
+    # rubocop:enable Metrics
+  end
+end

data/lib/mxrb/uml/class_diagram.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative 'support'
+
+module Mxrb
+  module Uml
+    # Projects Mendix domain models as Mermaid and PlantUML class diagrams.
+    # rubocop:disable Metrics/AbcSize
+    class ClassDiagram
+      TYPES = {
+        string: 'String', integer: 'Integer', long: 'Long', float: 'Float',
+        decimal: 'Decimal', boolean: 'Boolean', datetime: 'DateTime',
+        autonumber: 'AutoNumber', hashstring: 'HashedString', binary: 'Binary',
+        enum: 'Enumeration'
+      }.freeze
+
+      def initialize(modules)
+        @modules = Array(modules)
+        @entities = @modules.flat_map(&:entities)
+        @module_by_entity = @modules.each_with_object({}) do |mod, result|
+          mod.entities.each { result[_1.id.to_s] = mod.name.to_s }
+        end
+        @entity_by_key = @entities.each_with_object({}) do |entity, result|
+          qualified = qualified_name(entity)
+          result[entity.id.to_s] = entity
+          result[qualified] = entity
+        end
+      end
+
+      def to_mermaid
+        lines = ['classDiagram']
+        @entities.each { append_mermaid_class(lines, _1) }
+        associations.each { lines << mermaid_association(_1) }
+        "#{lines.join("\n")}\n"
+      end
+
+      def to_plantuml
+        lines = ['@startuml', 'hide empty methods']
+        @entities.each { append_plantuml_class(lines, _1) }
+        associations.each { lines << plantuml_association(_1) }
+        lines << '@enduml'
+        "#{lines.join("\n")}\n"
+      end
+
+      private
+
+      def append_mermaid_class(lines, entity)
+        identifier = entity_identifier(entity)
+        lines << %(class #{identifier}["#{Support.mermaid_text(qualified_name(entity))}"])
+        lines << "class #{identifier} {"
+        entity.attributes.each do |attribute|
+          lines << "  +#{attribute_type(attribute)} #{Support.mermaid_text(attribute.name)}"
+        end
+        lines << '}'
+        stereotype(entity).then { lines << "<<#{_1}>> #{identifier}" if _1 }
+      end
+
+      def append_plantuml_class(lines, entity)
+        identifier = entity_identifier(entity)
+        suffix = stereotype(entity).then { _1 ? " <<#{_1}>>" : '' }
+        lines << %(class "#{Support.plantuml_text(qualified_name(entity))}" as #{identifier}#{suffix} {)
+        entity.attributes.each do |attribute|
+          lines << "  +#{Support.plantuml_text(attribute.name)} : #{attribute_type(attribute)}"
+        end
+        lines << '}'
+      end
+
+      def associations
+        @modules.flat_map(&:associations).filter_map do |association|
+          from = @entity_by_key[association.from_entity_id.to_s]
+          to = @entity_by_key[association.to_entity_id.to_s]
+          [association, from, to] if from && to
+        end
+      end
+
+      def mermaid_association(tuple)
+        association, from, to = tuple
+        left, right = multiplicities(association)
+        label = Support.mermaid_text(association.name)
+        %(#{entity_identifier(from)} "#{left}" --> "#{right}" #{entity_identifier(to)} : #{label})
+      end
+
+      def plantuml_association(tuple)
+        association, from, to = tuple
+        left, right = multiplicities(association)
+        label = Support.plantuml_text(association.name)
+        %(#{entity_identifier(from)} "#{left}" --> "#{right}" #{entity_identifier(to)} : #{label})
+      end
+
+      def multiplicities(association)
+        association.association_type.to_sym == :ReferenceSet ? ['*', '*'] : %w[1 N]
+      end
+
+      def attribute_type(attribute)
+        return Support.words(attribute.enumeration.to_s.split('.').last) unless attribute.enumeration.to_s.empty?
+
+        TYPES.fetch(attribute.type.to_sym, Support.words(attribute.type))
+      end
+
+      def stereotype(entity)
+        return 'OQL View' if entity.respond_to?(:oql_view?) && entity.oql_view?
+        return 'DTO' unless entity.persistable == true
+
+        nil
+      end
+
+      def qualified_name(entity)
+        value = entity.qualified_name.to_s
+        return value unless value.empty?
+
+        "#{@module_by_entity.fetch(entity.id.to_s)}.#{entity.name}"
+      end
+
+      def entity_identifier(entity) = Support.identifier(qualified_name(entity), prefix: 'class')
+    end
+    # rubocop:enable Metrics/AbcSize
+  end
+end

data/lib/mxrb/uml/sequence_diagram.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative 'support'
+
+module Mxrb
+  module Uml
+    # Builds call-chain sequence diagrams from the existing semantic index.
+    # rubocop:disable Metrics
+    class SequenceDiagram
+      CALLABLE_KINDS = %i[microflow nanoflow].freeze
+      MAX_DEPTH = 100
+
+      def initialize(index, root: nil, module_name: nil, depth: 2)
+        raise ArgumentError, 'choose either root or module_name' if root && module_name
+        raise ArgumentError, 'root or module_name is required' unless root || module_name
+
+        @index = index
+        @root = root
+        @module_name = module_name
+        @depth = Integer(depth)
+        raise ArgumentError, 'depth must be zero or greater' if @depth.negative?
+        raise ArgumentError, "depth cannot exceed #{MAX_DEPTH}" if @depth > MAX_DEPTH
+
+        @edges, @selected = root ? root_graph : module_graph
+        @participants = participants
+      end
+
+      def to_mermaid
+        lines = ['sequenceDiagram']
+        @participants.each do |artifact|
+          lines << %(  participant #{participant_id(artifact)} as #{Support.mermaid_text(artifact.qualified_name)})
+        end
+        @edges.each do |source, target|
+          lines << "  #{participant_id(source)}->>#{participant_id(target)}: call"
+        end
+        append_mermaid_empty_note(lines) if @edges.empty?
+        "#{lines.join("\n")}\n"
+      end
+
+      def to_plantuml
+        lines = ['@startuml']
+        @participants.each do |artifact|
+          lines << %(participant "#{Support.plantuml_text(artifact.qualified_name)}" as #{participant_id(artifact)})
+        end
+        @edges.each do |source, target|
+          lines << "#{participant_id(source)} -> #{participant_id(target)} : call"
+        end
+        lines << 'note "No call relationships found" as MXRB' if @edges.empty?
+        lines << '@enduml'
+        "#{lines.join("\n")}\n"
+      end
+
+      private
+
+      def root_graph
+        root = @index.find(@root)
+        raise ArgumentError, "microflow not found: #{@root}" unless root && CALLABLE_KINDS.include?(root.kind)
+
+        edges = []
+        visited = {}
+        visit = lambda do |source, level|
+          return if level >= @depth || visited.key?(source.id)
+
+          visited[source.id] = true
+          callees(source).each do |target|
+            edges << [source, target]
+            visit.call(target, level + 1)
+          end
+        end
+        visit.call(root, 0)
+        [edges.uniq { [_1.id, _2.id] }, [root]]
+      end
+
+      def module_graph
+        sources = @index.artifacts.select do |artifact|
+          artifact.module_name == @module_name.to_s && CALLABLE_KINDS.include?(artifact.kind)
+        end
+        raise ArgumentError, "module not found or has no microflows: #{@module_name}" if sources.empty?
+
+        edges = sources.flat_map do |source|
+          callees(source).filter_map do |target|
+            [source, target] if target.module_name == @module_name.to_s
+          end
+        end
+        edges = edges.uniq { [_1.id, _2.id] }
+        [edges, sources]
+      end
+
+      def callees(source)
+        @index.references_from(source).filter_map do |reference|
+          reference.target if reference.relation == :calls && CALLABLE_KINDS.include?(reference.target.kind)
+        end.uniq(&:id)
+      end
+
+      def participants
+        (@selected + @edges.flatten).uniq(&:id).sort_by(&:qualified_name)
+      end
+
+      def append_mermaid_empty_note(lines)
+        participant = @participants.first
+        lines << if participant
+                   "  Note over #{participant_id(participant)}: No call relationships found"
+                 else
+                   '  Note over MXRB: No call relationships found'
+                 end
+      end
+
+      def participant_id(artifact) = Support.identifier(artifact.qualified_name, prefix: 'participant')
+    end
+    # rubocop:enable Metrics
+  end
+end

data/lib/mxrb/uml/server.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'json'
+
+require_relative '../web_ui'
+require_relative '../http/server'
+require_relative '../modeler/catalog'
+
+module Mxrb
+  module Uml
+    # Loopback-only unified viewer for class, activity, and sequence diagrams.
+    # rubocop:disable Metrics
+    class Server
+      LOOPBACK_HOSTS = %w[127.0.0.1 ::1 localhost].freeze
+
+      attr_reader :source, :host, :port
+
+      def initialize(source, host: '127.0.0.1', port: 4569)
+        @source = File.expand_path(source)
+        raise ArgumentError, "MPR not found: #{@source}" unless File.file?(@source)
+
+        @host = host.to_s
+        raise ArgumentError, 'UML server must bind to loopback' unless LOOPBACK_HOSTS.include?(@host)
+
+        @port = Integer(port)
+      end
+
+      def start
+        @server = Http::Server.new(host:, port:) { dispatch(_1, _2) }
+        @server.start { yield(_1) if block_given? }
+      end
+
+      def shutdown = @server&.shutdown
+
+      private
+
+      def dispatch(request, response)
+        return render(response, 200, WebUi.page('uml'), 'text/html; charset=utf-8') \
+          if request.request_method == 'GET' && request.path == '/'
+        return render(response, 200, WebUi.page('modeler'), 'text/html; charset=utf-8') \
+          if request.request_method == 'GET' && request.path == '/modeler'
+
+        if request.request_method == 'GET' && request.path.start_with?('/assets/')
+          asset = WebUi.asset(request.path)
+          return render(response, 200, *asset) if asset
+
+          return json(response, 404, ok: false, error: 'not_found')
+        end
+        return json(response, 405, ok: false, error: 'method_not_allowed') unless request.request_method == 'GET'
+
+        payload = case request.path
+                  when '/api/class' then class_payload(request.query)
+                  when '/api/activity' then activity_payload(request.query)
+                  when '/api/sequence' then sequence_payload(request.query)
+                  when '/api/catalog' then catalog_payload
+                  when '/api/project' then Modeler::Catalog.new(source).to_h
+                  end
+        return json(response, 404, ok: false, error: 'not_found') unless payload
+
+        json(response, 200, payload)
+      rescue ArgumentError, KeyError, Mxrb::Error => e
+        json(response, 422, ok: false, error: e.message)
+      end
+
+      def class_payload(query)
+        selected = query.fetch('modules', '').split(',').map(&:strip).reject(&:empty?)
+        with_project do |project|
+          modules = project.modules
+          unless selected.empty?
+            unknown = selected - modules.map(&:name)
+            raise ArgumentError, "unknown modules: #{unknown.join(', ')}" unless unknown.empty?
+
+            modules = modules.select { selected.include?(_1.name) }
+          end
+          formats(ClassDiagram.new(modules))
+        end
+      end
+
+      def activity_payload(query)
+        qualified = query.fetch('microflow') { raise ArgumentError, 'microflow is required' }
+        with_project do |project|
+          flow = find_microflow(project, qualified)
+          raise ArgumentError, "microflow not found: #{qualified}" unless flow
+
+          formats(ActivityDiagram.new(flow))
+        end
+      end
+
+      def sequence_payload(query)
+        root = query['root']
+        module_name = query['module']
+        raise ArgumentError, 'root or module is required' if root.to_s.empty? && module_name.to_s.empty?
+
+        with_project do |project|
+          diagram = SequenceDiagram.new(
+            project.semantic_index,
+            root: root.to_s.empty? ? nil : root,
+            module_name: module_name.to_s.empty? ? nil : module_name,
+            depth: query.fetch('depth', 2)
+          )
+          formats(diagram)
+        end
+      end
+
+      def catalog_payload
+        with_project do |project|
+          {
+            modules: project.modules.map(&:name).sort,
+            microflows: project.modules.flat_map do |mod|
+              mod.microflows.map { "#{mod.name}.#{_1.name}" }
+            end.sort
+          }
+        end
+      end
+
+      def find_microflow(project, qualified)
+        module_name, flow_name = qualified.to_s.split('.', 2)
+        return unless flow_name
+
+        project.modules.find { _1.name == module_name }&.microflows&.find { _1.name == flow_name }
+      end
+
+      def with_project
+        project = Model::Project.open(source)
+        yield project
+      ensure
+        project&.close
+      end
+
+      def formats(diagram) = { mermaid: diagram.to_mermaid, plantuml: diagram.to_plantuml }
+
+      def json(response, status, payload)
+        render(response, status, JSON.generate(payload), 'application/json; charset=utf-8')
+      end
+
+      def render(response, status, body, type)
+        response.status = status
+        response['Content-Type'] = type
+        response['Cache-Control'] = 'no-store'
+        response['X-Content-Type-Options'] = 'nosniff'
+        response.body = body
+      end
+    end
+    # rubocop:enable Metrics
+  end
+end

data/lib/mxrb/uml/support.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Mxrb
+  module Uml
+    # Shared, deterministic escaping and identifier helpers for text formats.
+    module Support
+      module_function
+
+      def identifier(value, prefix: 'n')
+        raw = value.to_s
+        body = raw.gsub(/[^A-Za-z0-9_]/, '_')
+        body = prefix if body.empty?
+        body = "#{prefix}_#{body}" unless body.match?(/\A[A-Za-z_]/)
+        body += "_#{Digest::SHA256.hexdigest(raw)[0, 8]}" unless body == raw
+        body
+      end
+
+      def mermaid_text(value)
+        value.to_s.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;')
+             .gsub('"', '&quot;').gsub(/[\r\n]+/, ' ')
+      end
+
+      def plantuml_text(value)
+        value.to_s.gsub('\\') { '\\\\' }.gsub('"', '\\"').gsub(/[\r\n]+/, ' ')
+      end
+
+      def words(value)
+        value.to_s.delete_prefix('Microflows$').delete_suffix('Action')
+             .gsub(/([a-z0-9])([A-Z])/, '\\1 \\2').tr('_', ' ').strip
+      end
+    end
+  end
+end

data/lib/mxrb/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mxrb
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

data/lib/mxrb/web_ui/assets/abnfDiagram-N423BO3Z-C4JD3cEC.js

@@ -0,0 +1 @@
+import{n as e}from"./chunk-Y2CYZVJY-DsF7k-Jl.js";import{m as t}from"./src-CvxfUak2.js";import"./chunk-I66GZJ75-CulcrLPh.js";import"./uml-C3KAFGTq.js";import{m as n,t as r}from"./mermaid-parser.core-B_UPzTxa.js";import{n as i,r as a,t as o}from"./chunk-6Q2QTUOP-wQkNmt_X.js";import{t as s}from"./chunk-JWPE2WC7-DVXcaiue.js";var c=n().RailroadAbnf.parser.LangiumParser,l=e(e=>{let t=e.alternatives.map(u);return t.length===1?t[0]:{type:`choice`,alternatives:t}},`transformAlternation`),u=e(e=>{let t=e.elements.map(f);return t.length===1?t[0]:{type:`sequence`,elements:t}},`transformConcatenation`),d=e(e=>{if(e.includes(`*`)){let[t,n]=e.split(`*`);return{min:t?parseInt(t,10):0,max:n?parseInt(n,10):1/0}}let t=parseInt(e,10);return{min:t,max:t}},`parseRepeat`),f=e(e=>{let t=p(e.primary);if(!e.repeat)return t;let{min:n,max:r}=d(e.repeat);return n===0&&r===1?{type:`optional`,element:t}:{type:`repetition`,element:t,min:n,max:r}},`transformElement`),p=e(e=>{switch(e.$type){case`AbnfStringLiteral`:return{type:`terminal`,value:e.value};case`AbnfNumVal`:return{type:`terminal`,value:e.value};case`AbnfRuleName`:return{type:`nonterminal`,name:e.name};case`AbnfGroup`:return l(e.element);case`AbnfOptionalGroup`:return{type:`optional`,element:l(e.element)};default:throw Error(`Unsupported ABNF primary node: ${e.$type}`)}},`transformPrimary`),m=e(e=>({name:e.name,definition:l(e.definition)}),`transformRule`),h=e(e=>{s(e,o),e.title&&o.setTitle(e.title),e.rules.map(e=>o.addRule(m(e)))},`populateDb`),g={parser:{parse:e(e=>{o.clear(),t.debug(`[ABNF Parser] Starting Langium parse`);let n=c.parse(e);if(n.lexerErrors.length>0||n.parserErrors.length>0)throw new r(n);let i=n.value;t.debug(`[ABNF Parser] Parsed rules:`,i.rules.length),h(i),t.debug(`[ABNF Parser] Parse complete`)},`parse`),parser:{yy:o}},db:o,renderer:a,styles:i};export{g as diagram};

data/lib/mxrb/web_ui/assets/arc-3Z53kgFp.js

@@ -0,0 +1 @@
+import{n as e,t}from"./path-fybaL0A-.js";import{a as n,c as r,d as i,f as a,i as o,l as s,m as c,n as l,o as u,p as d,r as f,u as p}from"./dist-D2qOEbeJ.js";function m(e){return e.innerRadius}function h(e){return e.outerRadius}function g(e){return e.startAngle}function _(e){return e.endAngle}function v(e){return e&&e.padAngle}function y(e,t,n,r,i,a,o,s){var c=n-e,l=r-t,u=o-i,d=s-a,f=d*c-u*l;if(!(f*f<1e-12))return f=(u*(t-a)-d*(e-i))/f,[e+f*c,t+f*l]}function b(e,t,n,r,i,a,o){var c=e-n,l=t-r,u=(o?a:-a)/d(c*c+l*l),f=u*l,p=-u*c,m=e+f,h=t+p,g=n+f,_=r+p,v=(m+g)/2,y=(h+_)/2,b=g-m,x=_-h,S=b*b+x*x,C=i-a,w=m*_-g*h,T=(x<0?-1:1)*d(s(0,C*C*S-w*w)),E=(w*x-b*T)/S,D=(-w*b-x*T)/S,O=(w*x+b*T)/S,k=(-w*b+x*T)/S,A=E-v,j=D-y,M=O-v,N=k-y;return A*A+j*j>M*M+N*N&&(E=O,D=k),{cx:E,cy:D,x01:-f,y01:-p,x11:E*(i/C-1),y11:D*(i/C-1)}}function x(){var s=m,x=h,S=e(0),C=null,w=g,T=_,E=v,D=null,O=t(k);function k(){var e,t,m=+s.apply(this,arguments),h=+x.apply(this,arguments),g=w.apply(this,arguments)-r,_=T.apply(this,arguments)-r,v=l(_-g),k=_>g;if(D||=e=O(),h<m&&(t=h,h=m,m=t),!(h>1e-12))D.moveTo(0,0);else if(v>c-1e-12)D.moveTo(h*u(g),h*a(g)),D.arc(0,0,h,g,_,!k),m>1e-12&&(D.moveTo(m*u(_),m*a(_)),D.arc(0,0,m,_,g,k));else{var A=g,j=_,M=g,N=_,P=v,F=v,I=E.apply(this,arguments)/2,L=I>1e-12&&(C?+C.apply(this,arguments):d(m*m+h*h)),R=p(l(h-m)/2,+S.apply(this,arguments)),z=R,B=R,V,H;if(L>1e-12){var U=o(L/m*a(I)),W=o(L/h*a(I));(P-=U*2)>1e-12?(U*=k?1:-1,M+=U,N-=U):(P=0,M=N=(g+_)/2),(F-=W*2)>1e-12?(W*=k?1:-1,A+=W,j-=W):(F=0,A=j=(g+_)/2)}var G=h*u(A),K=h*a(A),q=m*u(N),J=m*a(N);if(R>1e-12){var Y=h*u(j),X=h*a(j),Z=m*u(M),Q=m*a(M),$;if(v<i){if($=y(G,K,Z,Q,Y,X,q,J)){var ee=G-$[0],te=K-$[1],ne=Y-$[0],re=X-$[1],ie=1/a(f((ee*ne+te*re)/(d(ee*ee+te*te)*d(ne*ne+re*re)))/2),ae=d($[0]*$[0]+$[1]*$[1]);z=p(R,(m-ae)/(ie-1)),B=p(R,(h-ae)/(ie+1))}else z=B=0}}F>1e-12?B>1e-12?(V=b(Z,Q,G,K,h,B,k),H=b(Y,X,q,J,h,B,k),D.moveTo(V.cx+V.x01,V.cy+V.y01),B<R?D.arc(V.cx,V.cy,B,n(V.y01,V.x01),n(H.y01,H.x01),!k):(D.arc(V.cx,V.cy,B,n(V.y01,V.x01),n(V.y11,V.x11),!k),D.arc(0,0,h,n(V.cy+V.y11,V.cx+V.x11),n(H.cy+H.y11,H.cx+H.x11),!k),D.arc(H.cx,H.cy,B,n(H.y11,H.x11),n(H.y01,H.x01),!k))):(D.moveTo(G,K),D.arc(0,0,h,A,j,!k)):D.moveTo(G,K),!(m>1e-12)||!(P>1e-12)?D.lineTo(q,J):z>1e-12?(V=b(q,J,Y,X,m,-z,k),H=b(G,K,Z,Q,m,-z,k),D.lineTo(V.cx+V.x01,V.cy+V.y01),z<R?D.arc(V.cx,V.cy,z,n(V.y01,V.x01),n(H.y01,H.x01),!k):(D.arc(V.cx,V.cy,z,n(V.y01,V.x01),n(V.y11,V.x11),!k),D.arc(0,0,m,n(V.cy+V.y11,V.cx+V.x11),n(H.cy+H.y11,H.cx+H.x11),k),D.arc(H.cx,H.cy,z,n(H.y11,H.x11),n(H.y01,H.x01),!k))):D.arc(0,0,m,N,M,k)}if(D.closePath(),e)return D=null,e+``||null}return k.centroid=function(){var e=(+s.apply(this,arguments)+ +x.apply(this,arguments))/2,t=(+w.apply(this,arguments)+ +T.apply(this,arguments))/2-i/2;return[u(t)*e,a(t)*e]},k.innerRadius=function(t){return arguments.length?(s=typeof t==`function`?t:e(+t),k):s},k.outerRadius=function(t){return arguments.length?(x=typeof t==`function`?t:e(+t),k):x},k.cornerRadius=function(t){return arguments.length?(S=typeof t==`function`?t:e(+t),k):S},k.padRadius=function(t){return arguments.length?(C=t==null?null:typeof t==`function`?t:e(+t),k):C},k.startAngle=function(t){return arguments.length?(w=typeof t==`function`?t:e(+t),k):w},k.endAngle=function(t){return arguments.length?(T=typeof t==`function`?t:e(+t),k):T},k.padAngle=function(t){return arguments.length?(E=typeof t==`function`?t:e(+t),k):E},k.context=function(e){return arguments.length?(D=e??null,k):D},k}export{x as t};

data/lib/mxrb/web_ui/assets/architecture-TIHT7OUA-BStBTLea.js

@@ -0,0 +1 @@
+import"./chunk-KEIR6QF5-BICK3FdT.js";import{M as e}from"./mermaid-parser.core-B_UPzTxa.js";export{e as createArchitectureServices};