periplus-map 0.2.1__py3-none-any.whl

periplus/packs/php_basic@0.2.0/imports/imports.yaml

@@ -0,0 +1,19 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# The import statements a file's written names resolve through. The facts name tree fields: alias
+# holds an alias, and type holds the function or const keyword of a use that binds no type name.
+# bind says how a clause binds: its alias, else the last segment of its written path, names it; a
+# grouped use joins each member to its prefix; a leading backslash is stripped; a use with a kind
+# keyword binds nothing.
+imports:
+- ast: namespace_use_declaration
+  group_ast: namespace_use_group
+  clause: namespace_use_clause
+  facts:
+    alias: alias
+    use_kind: type
+  bind:
+    name: [alias, last_segment]
+    prefix_from_group: true
+    strip_prefix: "\\"
+    skip_when_field_set: use_kind

periplus/packs/php_basic@0.2.0/pack.yaml

@@ -0,0 +1,94 @@
+$schema: "https://periplus.dev/schema/0/pack-manifest.schema.json"
+
+# The basic PHP pack: every class, interface, trait, enum, function and method becomes a node
+# under its full name, and a class-like gets its inherits, implements, mixes_in and contains edges.
+# It sits beside the reference pack php and does not replace it.
+#
+# Known gaps. A call to a function PHP itself defines, such as strlen() or json_decode(), makes
+# nothing: the rule calls_function lists the 2150 names get_defined_functions()['internal']
+# returned in one run of PHP 8.5.11 (cli, NTS), beside PHP's language constructs; exit and die are
+# in both and listed once. That run loaded
+# these extensions: Core, date, lexbor, openssl, pcre, sqlite3, zlib, bcmath, bz2, calendar, ctype,
+# curl, dba, uri, json, mbstring, SPL, FFI, fileinfo, filter, ftp, gd, gettext, gmp, hash, iconv,
+# intl, session, ldap, standard, libxml, mysqlnd, mysqli, odbc, Zend OPcache, pcntl, PDO,
+# pdo_dblib, pdo_mysql, PDO_ODBC, pdo_pgsql, pdo_sqlite, pgsql, Phar, posix, random, readline,
+# Reflection, exif, shmop, SimpleXML, snmp, soap, sockets, sodium, sysvmsg, sysvsem, sysvshm, tidy,
+# tokenizer, dom, xml, xmlreader, xmlwriter, xsl, zip. A function of an extension not loaded there
+# is not listed.
+#
+# False results:
+# - The names are compared with the text as written. A builtin called with a leading backslash,
+#   \strlen(), or in another letter case, StrLen(), still gives an unresolved function node.
+# - A function the project declares under a builtin name, function strlen() in its namespace, gets
+#   no calls edge from an unqualified call to it: no rule can yet try the namespaced name and then
+#   the bare one in order.
+# - Drupal's global functions, such as t(), drupal_flush_all_caches() and theme_get_setting(), are
+#   not PHP builtins: a call to one still gives an unresolved function node.
+#
+# Missing results:
+# - A method call on an object, $x->m(), makes nothing, except a call on a property of $this
+#   whose type the same class declares, or that the calling class, or its nearest ancestor
+#   declaring the property, assigns from a parameter typed by a class name: only plain function
+#   calls, static calls and those are read. A property typed by a union of two or more class names,
+#   Helper|Other, gives no edge, and neither does a call in a parent class through a property only
+#   a child assigns; the call keeps its php.call_site node.
+# - A use function alias does not bind.
+pack: php_basic
+version: 0.2.0
+depends: []
+
+# Pinned exactly: the rules name tree node types, and those can change across grammar releases.
+grammar:
+  provider: tree-sitter
+  provider_version: "0.26.0"
+  language: php
+  grammar_version: "0.24.1"
+
+# The whole project at any depth; a dependent pack or the project settings narrows it.
+folders:
+  source: ./**
+
+files:
+  extensions: [php]
+  exclude:
+  - '**/vendor/**'
+  - '**/node_modules/**'
+
+# How a full name is built, read by the engine as data. namespace names the tree node that
+# declares a namespace and the field holding its name; written_names are the tree node types of a
+# name written in source, such as the names after extends.
+identity:
+  qualified_name:
+    parts: [namespace, declared_name]
+    separator: "\\"
+  namespace:
+    declaration: namespace_definition
+    name_child: name
+  written_names: [name, qualified_name, namespace_name]
+  # How a written name becomes a full one, the first step that holds giving it: a name with a
+  # leading backslash is full without it; a name whose first segment a use of its namespace block
+  # binds takes the used path in place of that segment; any other name takes the namespace.
+  resolve:
+  - full_if_prefixed: "\\"
+  - bound_first_segment
+  - prefix_with: namespace
+  # How an attribute is written: its node, the list that holds it on a declaration, the field of
+  # its arguments, one argument and the field of its name, and the text literals with the node of
+  # their text.
+  attribute:
+    node: attribute
+    list: attribute_list
+    arguments: parameters
+    argument: argument
+    argument_name: name
+    literals: [string, encapsed_string]
+    literal_content: string_content
+  # A call's arguments: their field, one argument and the field of its name, and the text
+  # literals with the node of their text. view('a') holds 'a' at position 0.
+  call_arguments: arguments
+  call_argument: argument
+  call_argument_name: name
+  call_literals: [string, encapsed_string]
+  call_literal_content: [string_content]
+  # The tree node type of a comment; a docblock is the comment just before a declaration.
+  comment: comment

periplus/packs/php_basic@0.2.0/types/find_declarations.yaml

@@ -0,0 +1,267 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# The type a class declares for a property, which the rules below find; node_types.yaml holds the
+# pack's other node types.
+node_types:
+
+- name: php.property_type
+  id_namespace: php.property_type
+
+# One rule per construct, because each names where its body lives: enum_declaration_list differs
+# from declaration_list by one word. A rule with a body_child is a type a method can sit in.
+rules:
+
+- rule: find_class
+  reads: file
+  in: [source]
+  match: {declaration: class_declaration, name_child: name, body_child: declaration_list, filetype: php}
+  id: {from: qualified_name}
+  emits: [{node: {type: php.class}}]
+  confidence: declared
+
+- rule: find_interface
+  reads: file
+  in: [source]
+  match: {declaration: interface_declaration, name_child: name, body_child: declaration_list, filetype: php}
+  id: {from: qualified_name}
+  emits: [{node: {type: php.interface}}]
+  confidence: declared
+
+- rule: find_trait
+  reads: file
+  in: [source]
+  match: {declaration: trait_declaration, name_child: name, body_child: declaration_list, filetype: php}
+  id: {from: qualified_name}
+  emits: [{node: {type: php.trait}}]
+  confidence: declared
+
+- rule: find_enum
+  reads: file
+  in: [source]
+  match: {declaration: enum_declaration, name_child: name, body_child: enum_declaration_list, filetype: php}
+  id: {from: qualified_name}
+  emits: [{node: {type: php.enum}}]
+  confidence: declared
+
+- rule: find_function
+  reads: file
+  in: [source]
+  match: {declaration: function_definition, name_child: name, filetype: php}
+  id: {from: qualified_name}
+  emits: [{node: {type: php.function}}]
+  confidence: declared
+
+# A method's id holds the full name of the type it sits in, so five build methods on five classes
+# stay five nodes.
+- rule: find_method
+  reads: file
+  in: [source]
+  match: {declaration: method_declaration, name_child: name, filetype: php}
+  id:
+    from: [enclosing_type, declared_name]
+    template: "{enclosing_type}::{declared_name}"
+  emits: [{node: {type: php.method}}]
+  confidence: declared
+
+# The parts of a call through a property of the enclosing object. A property, <class>::$<name>.
+- rule: find_property
+  reads: file
+  in: [source]
+  match: {declaration: property_element, name_child: name, filetype: php}
+  id:
+    from: [enclosing_type, declared_name]
+    template: "{enclosing_type}::{declared_name}"
+  emits: [{node: {type: php.property}}]
+  confidence: declared
+
+# The property a promoted constructor parameter declares, the same <class>::$<name>.
+- rule: find_promoted_property
+  reads: file
+  in: [source]
+  match: {declaration: property_promotion_parameter, name_child: name, filetype: php}
+  id:
+    from: [enclosing_type, declared_name]
+    template: "{enclosing_type}::{declared_name}"
+  emits: [{node: {type: php.property}}]
+  confidence: declared
+
+# A parameter of a method, <class>::<method>::$<name>, and for one typed by a class name its twin,
+# <class>::$<name>::<type>, the type resolved through the file's imports and namespace. A scalar,
+# nullable or union type gives no twin, and a function's parameter makes nothing. The twin keeps
+# the method out of its id, so find_structure.yaml's parameter_typed_as reaches it.
+- rule: find_parameter
+  reads: file
+  in: [source]
+  match: {declaration: simple_parameter, name_child: name, filetype: php}
+  id:
+    from: [enclosing_type, enclosing_method, declared_name]
+    template: "{enclosing_type}::{enclosing_method}::{declared_name}"
+  emits: [{node: {type: php.parameter}}]
+  confidence: declared
+
+- rule: find_parameter_type
+  reads: file
+  in: [source]
+  match: {declaration: simple_parameter, name_child: name, filetype: php, where: [{has_child: named_type}]}
+  id:
+    from: [enclosing_type, declared_name, {qualified: type}]
+    template: "{enclosing_type}::{declared_name}::{type}"
+  emits: [{node: {type: php.parameter_type}}]
+  confidence: declared
+
+# The type a class declares for a property, <class>::$<name>::<type>, resolved through the file's
+# imports and namespace: written on the property, private Mailer $mailer; on a promoted constructor
+# parameter; or in the @var line of the docblock before the property. A nullable class type,
+# ?Mailer, gives the class, and so does a union of one class name with null, false or scalars,
+# Mailer|null. A scalar, ?int, or a union of two class names, Mailer|Other, gives none, and so does
+# a @var of several types or of an array; a @var of a scalar, such as string, is read as a class
+# name. A declaration of several properties in one
+# statement names its first only. find_structure.yaml's property_typed_as reaches each.
+- rule: find_property_type
+  reads: file
+  in: [source]
+  match:
+    declaration: property_declaration
+    name_child: [property_element, name]
+    filetype: php
+    where: [{has_child: named_type}]
+  id:
+    from: [enclosing_type, declared_name, {qualified: type}]
+    template: "{enclosing_type}::{declared_name}::{type}"
+  emits: [{node: {type: php.property_type}}]
+  confidence: declared
+
+- rule: find_promoted_property_type
+  reads: file
+  in: [source]
+  match:
+    declaration: property_promotion_parameter
+    name_child: name
+    filetype: php
+    where: [{has_child: named_type}]
+  id:
+    from: [enclosing_type, declared_name, {qualified: type}]
+    template: "{enclosing_type}::{declared_name}::{type}"
+  emits: [{node: {type: php.property_type}}]
+  confidence: declared
+
+- rule: find_nullable_property_type
+  reads: file
+  in: [source]
+  match:
+    declaration: property_declaration
+    name_child: [property_element, name]
+    filetype: php
+    where: [{has_child: optional_type}]
+  id:
+    from: [enclosing_type, declared_name, {qualified: type}]
+    template: "{enclosing_type}::{declared_name}::{type}"
+  emits: [{node: {type: php.property_type}}]
+  confidence: declared
+
+- rule: find_nullable_promoted_property_type
+  reads: file
+  in: [source]
+  match:
+    declaration: property_promotion_parameter
+    name_child: name
+    filetype: php
+    where: [{has_child: optional_type}]
+  id:
+    from: [enclosing_type, declared_name, {qualified: type}]
+    template: "{enclosing_type}::{declared_name}::{type}"
+  emits: [{node: {type: php.property_type}}]
+  confidence: declared
+
+# {qualified: type} takes a union's first class-like name and skips null, false and scalars, so the
+# name_matches guard admits a union of one class name among those, in any order, and refuses two.
+- rule: find_union_property_type
+  reads: file
+  in: [source]
+  match:
+    declaration: property_declaration
+    name_child: [property_element, name]
+    filetype: php
+    where:
+    - has_child: union_type
+    - name_matches: {child: type, pattern: '(?i)^(?:(?:null|false|true|int|float|string|bool|array|iterable|mixed|callable)\s*\|\s*)*\\?[A-Za-z_][\w\\]*(?:\s*\|\s*(?:null|false|true|int|float|string|bool|array|iterable|mixed|callable))*$'}
+  id:
+    from: [enclosing_type, declared_name, {qualified: type}]
+    template: "{enclosing_type}::{declared_name}::{type}"
+  emits: [{node: {type: php.property_type}}]
+  confidence: declared
+
+- rule: find_union_promoted_property_type
+  reads: file
+  in: [source]
+  match:
+    declaration: property_promotion_parameter
+    name_child: name
+    filetype: php
+    where:
+    - has_child: union_type
+    - name_matches: {child: type, pattern: '(?i)^(?:(?:null|false|true|int|float|string|bool|array|iterable|mixed|callable)\s*\|\s*)*\\?[A-Za-z_][\w\\]*(?:\s*\|\s*(?:null|false|true|int|float|string|bool|array|iterable|mixed|callable))*$'}
+  id:
+    from: [enclosing_type, declared_name, {qualified: type}]
+    template: "{enclosing_type}::{declared_name}::{type}"
+  emits: [{node: {type: php.property_type}}]
+  confidence: declared
+
+- rule: find_var_property_type
+  reads: file
+  in: [source]
+  match: {declaration: property_declaration, name_child: [property_element, name], filetype: php}
+  id:
+    from:
+    - enclosing_type
+    - declared_name
+    - qualified: {docblock: '@var\s+\??(?<type>\\?[A-Za-z_][A-Za-z0-9_\\]*)(?:\|null)?(?:\s|\*)'}
+    template: "{enclosing_type}::{declared_name}::{type}"
+  emits: [{node: {type: php.property_type}}]
+  confidence: declared
+
+# An assignment to a property of the object, <class>::$this-><name>, one node for each class and
+# property; and its twin, <class>::<method>::$this-><name>=<right-hand text>, one for each method
+# and text. A text holding a line break is kept as written.
+- rule: find_member_assignment
+  reads: file
+  in: [source]
+  match:
+    declaration: assignment_expression
+    name_child: left
+    filetype: php
+    where: [{name_matches: {child: left, pattern: '\$this->\w+'}}]
+  id:
+    from: [enclosing_type, declared_name]
+    template: "{enclosing_type}::{declared_name}"
+  emits: [{node: {type: php.member_assignment}}]
+  confidence: declared
+
+- rule: find_member_assignment_value
+  reads: file
+  in: [source]
+  match:
+    declaration: assignment_expression
+    name_child: left
+    filetype: php
+    where: [{name_matches: {child: left, pattern: '\$this->\w+'}}]
+  id:
+    from: [enclosing_type, enclosing_method, declared_name, right]
+    template: "{enclosing_type}::{enclosing_method}::{declared_name}={right}"
+  emits: [{node: {type: php.member_assignment_value}}]
+  confidence: declared
+
+# A call on a property of the object, <class>::<method>::$this-><name>-><called method>.
+- rule: find_call_site
+  reads: file
+  in: [source]
+  match:
+    declaration: member_call_expression
+    name_child: object
+    filetype: php
+    where: [{name_matches: {child: object, pattern: '\$this->\w+'}}]
+  id:
+    from: [enclosing_type, enclosing_method, declared_name, name]
+    template: "{enclosing_type}::{enclosing_method}::{declared_name}->{name}"
+  emits: [{node: {type: php.call_site}}]
+  confidence: declared

periplus/packs/php_basic@0.2.0/types/node_types.yaml

@@ -0,0 +1,55 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# The node types this pack declares. Finding them is in types/find_declarations.yaml.
+#
+# A function and a class may share a name in PHP, so functions and methods each have their own id
+# namespace and do not share the class-likes' one.
+node_types:
+
+- name: php.class_like
+  abstract: true
+  id_namespace: php.type
+
+- name: php.class
+  parent: php.class_like
+
+- name: php.interface
+  parent: php.class_like
+
+- name: php.trait
+  parent: php.class_like
+
+- name: php.enum
+  parent: php.class_like
+
+- name: php.callable
+  abstract: true
+
+- name: php.function
+  parent: php.callable
+  id_namespace: php.function
+
+- name: php.method
+  parent: php.callable
+  id_namespace: php.method
+
+# The parts of a call through a property of the enclosing object, $this->mailer->send(), that
+# edges/find_structure.yaml joins in the map rule calls_through_assigned_property. Each is found at
+# its own line by a rule in types/find_declarations.yaml; its id is shaped there.
+- name: php.property
+  id_namespace: php.property
+
+- name: php.parameter
+  id_namespace: php.parameter
+
+- name: php.parameter_type
+  id_namespace: php.parameter_type
+
+- name: php.member_assignment
+  id_namespace: php.member_assignment
+
+- name: php.member_assignment_value
+  id_namespace: php.member_assignment_value
+
+- name: php.call_site
+  id_namespace: php.call_site

periplus/packs/profile_basic@0.0.1/bundle/profile_bundle_config.yaml

@@ -0,0 +1,54 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# A profile type read from its config file as the bundle profile.<id>, the id drupal_basic gives a field or
+# display of it. Two rules: the node with its label, and its edges.
+
+rules:
+- rule: bundle_profile_from_config
+  reads: file
+  in:
+  - config
+  - module_config
+  match:
+    file: profile.type.*
+    filetype: yaml
+  id:
+    from: file_stem
+    normalize:
+    - {replace: '^profile\.type\.', with: 'profile.'}
+  emits:
+  - node:
+      type: drupal.bundle
+  - attribute:
+      name: label
+      from:
+        key: label
+  confidence: declared
+- rule: bundle_profile_from_config_edges
+  reads: file
+  in:
+  - config
+  - module_config
+  match:
+    file: profile.type.*
+    filetype: yaml
+  id:
+    from: file_stem
+    normalize:
+    - {replace: '^profile\.type\.', with: 'profile.'}
+  emits:
+  - edge:
+      kind: configured_by
+      from: this_node
+      to:
+        from:
+          key: id
+        template: 'profile.type.{id}'
+  - edge:
+      kind: bundle_of
+      from: this_node
+      to:
+        from:
+          key: id
+        template: 'profile'
+  confidence: declared

periplus/packs/profile_basic@0.0.1/pack.yaml

@@ -0,0 +1,12 @@
+$schema: "https://periplus.dev/schema/0/pack-manifest.schema.json"
+
+# The Profile contributed module: each profile type, from its config file, as the bundle
+# profile.<id> with its label, a configured_by edge to that file and a bundle_of edge to the entity
+# type profile.
+#
+# Known gaps: the roles a profile type is limited to, and its registration and multiple settings,
+# give nothing. The entity type profile is declared by the module's PHP, which is not mapped, so it
+# stays referenced.
+pack: profile_basic
+version: 0.0.1
+depends: [drupal_basic]

periplus/packs/salesforce_basic@0.0.1/event/salesforce_event.yaml

@@ -0,0 +1,36 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# A Salesforce event, named by its SalesforceEvents constant as written, as
+# SalesforceEvents::PULL_QUERY. Read from PHP as text, where a subscriber's getSubscribedEvents
+# keys it: SalesforceEvents::X => 'method', or $events[SalesforceEvents::X][] = .... A use of the
+# constant as a value, as in a test's assertArrayHasKey(SalesforceEvents::X, ...), makes nothing.
+# The id is the constant's name, not the event name it holds, such as salesforce.pull_query. The
+# class the file's path names by Drupal's PSR-4 layout subscribes to the event, so the edge is
+# inferred and a file outside a src folder makes no edge. The Salesforce module defines the
+# event and is not in the mapped code, so the event is the referenced end of the edge and no
+# rule makes it a node of its own.
+
+node_types:
+- name: salesforce.event
+  id_namespace: salesforce.event
+
+edge_kinds:
+- kind: subscribes_to_salesforce_event
+  from: php.class
+  to: salesforce.event
+
+rules:
+- rule: salesforce_event_subscribed_by_class
+  reads: file
+  in: [source]
+  match:
+    file: '**'
+    filetype: drupal_php_text
+    text: '\bSalesforceEvents::(?<event>[A-Z][A-Z0-9_]*)\s*(?:=>|\]\s*\[\s*\]\s*=)'
+  id: {template: '{psr4_class}'}
+  emits:
+  - edge:
+      kind: subscribes_to_salesforce_event
+      from: this_node
+      to: {template: 'SalesforceEvents::{event}', types: [salesforce.event]}
+  confidence: inferred

periplus/packs/salesforce_basic@0.0.1/pack.yaml

@@ -0,0 +1,31 @@
+$schema: "https://periplus.dev/schema/0/pack-manifest.schema.json"
+
+# The Salesforce contributed modules: their mapping field plugins, by annotation, each joined to
+# its class by plugin_class; each mapping config file as a salesforce.mapping on its config node,
+# with its Salesforce object and its push and pull standalone flags, a maps_bundle edge to
+# <drupal_entity_type>.<drupal_bundle>, a maps_entity_type edge, and an inferred maps_field edge to
+# each field instance its dependencies.config lists; and each SalesforceEvents constant a
+# subscriber keys, as a salesforce.event, read as text through drupal_basic's drupal_php_text.
+#
+# Known gaps:
+# - The mapping field manager reads the generic Plugin annotation, so any class in the folder
+#   below that carries a Plugin annotation is read as a mapping field. An id that is not text in
+#   double quotes makes no plugin and is listed under skipped. The other Salesforce plugin types,
+#   such as auth providers and pull queue workers, give nothing.
+# - A mapping's field_mappings list is not read: a list source's each part names the key, not its
+#   value. So a field mapped by a property path, such as field_my_date.value, which the
+#   dependencies do not list, gives no maps_field edge, and nor does any mapping's Salesforce
+#   field, direction or mapping field plugin. A mapping whose dependencies list no field instance,
+#   as a webform submission mapping, is listed under skipped: fired and emitted nothing.
+# - A mapping's sync triggers, pull settings and key give nothing. The auth provider config,
+#   salesforce.salesforce_auth.*, and salesforce_logger.settings stay plain config objects.
+# - An event is named by its constant as written, less any namespace. One used through an alias,
+#   or as the event's own text, such as 'salesforce.pull_query', makes no event. No edge joins a
+#   subscriber to its event: that rule belongs to drupal_basic.
+pack: salesforce_basic
+version: 0.0.1
+depends: [drupal_basic, php_basic]
+
+folders:
+  # The folder the mapping field manager discovers in, below a module's src folder.
+  salesforce_mapping_field_classes: "{module_root}/src/Plugin/SalesforceMappingField/**"

periplus/packs/salesforce_basic@0.0.1/salesforce_mapping/salesforce_mapping.yaml

@@ -0,0 +1,19 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# A Salesforce mapping: a config entity that syncs one Drupal bundle with one Salesforce object.
+# It refines the config object of its file, so it shares that node's id.
+
+node_types:
+- name: salesforce.mapping
+  parent: drupal.config_object
+
+edge_kinds:
+- kind: maps_bundle
+  from: salesforce.mapping
+  to: drupal.bundle
+- kind: maps_entity_type
+  from: salesforce.mapping
+  to: drupal.entity_type
+- kind: maps_field
+  from: salesforce.mapping
+  to: drupal.field_instance

periplus/packs/salesforce_basic@0.0.1/salesforce_mapping/salesforce_mapping_config.yaml

@@ -0,0 +1,83 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# A Salesforce mapping read from its config file: the node with the Salesforce object and the two
+# standalone flags, and its edges. The bundle is {drupal_entity_type}.{drupal_bundle}. Each field
+# instance the mapping's dependencies.config lists is a maps_field edge, inferred: Salesforce
+# writes those dependencies from the field mappings, so a base field such as title, a constant or
+# a token gives none. The field mappings themselves are not read: a list source's each part fills
+# {key} with the key name drupal_field_value, not its value.
+
+rules:
+- rule: salesforce_mapping_from_config
+  reads: file
+  in:
+  - config
+  - module_config
+  match:
+    file: salesforce_mapping.salesforce_mapping.*
+    filetype: yaml
+  id:
+    from: file_stem
+  emits:
+  - node:
+      type: salesforce.mapping
+  - attribute:
+      name: salesforce_object
+      from:
+        key: salesforce_object_type
+  - attribute:
+      name: push_standalone
+      from:
+        key: push_standalone
+  - attribute:
+      name: pull_standalone
+      from:
+        key: pull_standalone
+  confidence: declared
+- rule: salesforce_mapping_from_config_edges
+  reads: file
+  in:
+  - config
+  - module_config
+  match:
+    file: salesforce_mapping.salesforce_mapping.*
+    filetype: yaml
+  id:
+    from: file_stem
+  emits:
+  - edge:
+      kind: maps_bundle
+      from: this_node
+      to:
+        from:
+        - key: drupal_entity_type
+        - key: drupal_bundle
+        template: '{drupal_entity_type}.{drupal_bundle}'
+  - edge:
+      kind: maps_entity_type
+      from: this_node
+      to:
+        from:
+          key: drupal_entity_type
+  confidence: declared
+- rule: salesforce_mapping_fields_from_config
+  reads: file
+  in:
+  - config
+  - module_config
+  match:
+    file: salesforce_mapping.salesforce_mapping.*
+    filetype: yaml
+  id:
+    from: file_stem
+  emits:
+  - edge:
+      kind: maps_field
+      from: this_node
+      to:
+        from:
+          key: dependencies.config
+        each: true
+        where:
+        - matches: 'field.field.*'
+  confidence: inferred

periplus/packs/salesforce_basic@0.0.1/salesforce_mapping_field/salesforce_mapping_field.yaml

@@ -0,0 +1,8 @@
+$schema: "https://periplus.dev/schema/0/pack-file.schema.json"
+
+# A Salesforce mapping field plugin, named by its plugin id; plugin_class joins it to its class.
+
+node_types:
+- name: drupal.salesforce_mapping_field
+  parent: drupal.plugin
+  id_namespace: drupal.plugin.salesforce_mapping_field