@accordproject/concerto-linter-default-ruleset 1.0.0

package/.eslintignore

@@ -0,0 +1,20 @@
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+coverage
+node_modules
+out
+lib/parser.js
+test/data
+dist

package/.eslintrc.yml

@@ -0,0 +1,45 @@
+env:
+    es6: true
+    node: true
+    mocha: true
+extends:
+ - 'eslint:recommended'
+ - 'plugin:@typescript-eslint/eslint-recommended'
+ - 'plugin:@typescript-eslint/recommended'
+parser: '@typescript-eslint/parser'
+plugins:
+ - '@typescript-eslint'
+parserOptions:
+    ecmaVersion: 13
+    sourceType: script
+rules:
+    indent:
+        - error
+        - 4
+    linebreak-style:
+        - warn
+        - unix
+    quotes:
+        - error
+        - single
+    semi:
+        - error
+        - always
+    no-console: warn
+    curly: error
+    eqeqeq: error
+    no-throw-literal: error
+    strict: 0
+    no-var: error
+    dot-notation: error
+    no-tabs: error
+    no-trailing-spaces: error
+    # no-use-before-define: error
+    no-useless-call: error
+    no-with: error
+    operator-linebreak: error
+    require-jsdoc: 0
+    valid-jsdoc:
+        - error
+        - requireReturn: false
+    yoda: error

package/README.md

@@ -0,0 +1,300 @@
+# Concerto Linter Default Ruleset
+
+A comprehensive set of linting rules designed to validate concerto models against industry best practices and consistent naming conventions. This default ruleset helps maintain high-quality, readable, and maintainable concerto models across your projects. It is fully configurable - you can extend it, add new rules, disable existing ones, or create an entirely new ruleset without extending this one.
+
+This sub-package is part of the `@accordproject/concerto-linter` package. Read the [concerto-linter README](https://github.com/accordproject/concerto/tree/main/packages/concerto-linter) if you want to know how to use this ruleset with concerto models.
+
+## Table of Contents
+
+- [Concerto Linter Default Ruleset](#concerto-linter-default-ruleset)
+  - [Table of Contents](#table-of-contents)
+  - [Key Benefits](#key-benefits)
+  - [Available Rules](#available-rules)
+  - [Installation](#installation)
+  - [Usage](#usage)
+  - [Customization](#customization)
+    - [Extending the Default Ruleset](#extending-the-default-ruleset)
+    - [Disabling Specific Rules](#disabling-specific-rules)
+      - [Available Rule IDs](#available-rule-ids)
+    - [Enabling Specific Rules](#enabling-specific-rules)
+    - [Adjusting Rule Severity](#adjusting-rule-severity)
+  - [Creating Custom Rules](#creating-custom-rules)
+  - [License](#license)
+
+## Key Benefits
+
+- **Consistent Code Style**: Enforce uniform naming conventions across your concerto models
+- **Error Prevention**: Catch common modeling mistakes before they cause issues
+- **Best Practices**: Apply industry-standard modeling practices automatically
+- **Customizable**: Easily extend or modify rules to match your project's specific needs
+- **Integration Ready**: Works seamlessly with the concerto Linter and your development workflow
+
+## Available Rules
+
+The following table provides an overview of the available linting rules in the default ruleset:
+
+<table>
+<tr>
+<th>Rule Id</th><th>Description</th>
+</tr>
+<tr>
+<td><a href="#namespace-version">namespace-version</a></td>
+<td>Ensures that the namespace declaration in the model includes a version number. This rule enforces semantic versioning in namespaces, promoting clarity and compatibility management.</td>
+</tr>
+<tr>
+<td><a href="#no-reserved-keywords">no-reserved-keywords</a></td>
+<td>Enforces that names used for declarations, properties, and decorators in concerto models do not use reserved keywords. Reserved keywords are language-specific terms that may cause conflicts or unexpected behavior if used as identifiers.</td>
+</tr>
+<tr>
+<td><a href="#pascal-case-declarations">pascal-case-declarations</a></td>
+<td>Ensures that declaration names (scalar, enum, concept, asset, participant, transaction, event) follow PascalCase naming convention (e.g., 'MyDeclaration'). This promotes consistency and readability across model declarations.</td>
+</tr>
+<tr>
+<td><a href="#camel-case-properties">camel-case-properties</a></td>
+<td>Ensures that properties of type String, Double, Integer, Long, DateTime, and Boolean are named using camelCase. This promotes consistency and readability in property naming conventions across the model.</td>
+</tr>
+<tr>
+<td><a href="#upper-snake-case-enum-constants">upper-snake-case-enum-constants</a></td>
+<td>Enforces that all enum constant names follow the UPPER_SNAKE_CASE convention. This rule checks each enum property name and reports an error if it does not match the required pattern. Ensures consistency and readability in enum naming across the model.</td>
+</tr>
+<tr>
+<td><a href="#pascal-case-decorators">pascal-case-decorators</a></td>
+<td>Ensures that decorator names follow PascalCase naming convention (e.g., 'MyDecorator'). This promotes consistency and readability across model decorators.</td>
+</tr>
+<tr>
+<td><a href="#string-length-validator">string-length-validator</a></td>
+<td>Ensures that all string properties within the data model have a length validator applied, which helps prevent inconsistent data length and ensure proper storage.</td>
+</tr>
+<tr>
+<td><a href="#no-empty-declarations">no-empty-declarations</a></td>
+<td>Detects and reports any model declarations that are empty. This rule helps maintain model integrity by ensuring that all declarations contain meaningful content, preventing the inclusion of unused or placeholder declarations in the model.</td>
+</tr>
+<tr>
+<td><a href="#abstract-must-subclassed">abstract-must-subclassed</a></td>
+<td>Ensures that every abstract declaration in the model has at least one concrete subclass. This helps prevent unused or orphaned abstract types, enforcing better model design.</td>
+</tr>
+</table> 
+
+## Installation
+
+First, install the package as a development dependency:
+
+```bash
+npm install --save-dev @accordproject/concerto-linter-default-ruleset
+```
+
+## Usage
+
+Once installed, the default ruleset is automatically used by the concerto Linter when no custom ruleset is specified:
+
+```javascript
+import { lintModel } from '@accordproject/concerto-linter';
+
+// The default ruleset will be used automatically
+const results = await lintModel(modelText);
+console.log(results);
+```
+
+To explicitly specify the default ruleset:
+
+```javascript
+const results = await lintModel(modelText, { ruleset: 'default' });
+```
+
+## Customization
+
+To create your own ruleset that fits your project needs, you can either extend the default ruleset, or create an entirely new ruleset from scratch.
+
+Your ruleset should be defined in one of these file formats: `.spectral.yaml`, `.spectral.yml`, `.spectral.json`, or `.spectral.js`. The concerto Linter will automatically detect and use these files, or you can specify a custom path using the `ruleset` property: `ruleset: "./path/to/my-ruleset.yaml"`. 
+
+### Extending the Default Ruleset
+
+You can extend the default ruleset in multiple formats:
+
+**YAML (.spectral.yaml)**
+```yaml
+extends: '@accordproject/concerto-linter-default-ruleset'
+```
+
+---
+
+**JSON (.spectral.json)**
+```json
+{
+  "extends": "@accordproject/concerto-linter-default-ruleset"
+}
+```
+
+---
+
+**JavaScript (.spectral.js)**
+```javascript
+const rules = require('@accordproject/concerto-linter-default-ruleset');
+module.exports = {
+  extends: rules
+};
+```
+
+### Disabling Specific Rules
+
+You can disable specific rules that don't match your project's requirements by setting them to `'off'`. The rule identifiers are defined in the `ruleset-main.ts` file located at `concerto/packages/concerto-linter/default-ruleset/src`.
+
+#### Available Rule IDs
+
+Here are all the rule IDs that can be disabled:
+
+| Rule ID | Description |
+|---------|-------------|
+| `namespace-version` | Ensures namespaces include version numbers |
+| `no-reserved-keywords` | Prevents use of reserved keywords |
+| `pascal-case-declarations` | Enforces PascalCase for declarations |
+| `camel-case-properties` | Enforces camelCase for properties |
+| `upper-snake-case-enum-constants` | Enforces UPPER_SNAKE_CASE for enum constants |
+| `pascal-case-decorators` | Enforces PascalCase for decorators |
+| `string-length-validator` | Requires string length validators |
+| `no-empty-declarations` | Prevents empty declarations |
+| `abstract-must-subclassed` | Ensures abstract classes have concrete subclasses |
+
+
+**YAML (.spectral.yaml)**
+```yaml
+extends: '@accordproject/concerto-linter-default-ruleset'
+rules:
+  pascal-case-declarations: 'off'
+  camel-case-properties: 'off'
+```
+
+---
+
+**JSON (.spectral.json)**
+```json
+{
+  "extends": "@accordproject/concerto-linter-default-ruleset",
+  "rules": {
+    "pascal-case-declarations": "off",
+    "camel-case-properties": "off"
+  }
+}
+```
+
+**JavaScript (.spectral.js)**
+```javascript
+const rules = require('@accordproject/concerto-linter-default-ruleset');
+module.exports = {
+  extends: rules,
+  rules: {
+    'pascal-case-declarations': off,
+    'namespace-version': off
+  }
+};
+```
+### Enabling Specific Rules
+
+You can selectively start with everything off and enable only specific rules:
+
+**YAML (.spectral.yaml)**
+```yaml
+extends: [['@accordproject/concerto-linter-default-ruleset', 'off']]
+rules:
+  pascal-case-declarations: true
+  namespace-version: true
+```
+
+**JSON (.spectral.json)**
+```json
+{
+  "extends": [["@accordproject/concerto-linter-default-ruleset", "off"]],
+  "rules": {
+    "pascal-case-declarations": true,
+    "namespace-version": true
+  }
+}
+```
+
+**JavaScript (.spectral.js)**
+```javascript
+const rules = require('@accordproject/concerto-linter-default-ruleset');
+module.exports = {
+  extends: [[rules, 'off']],
+  rules: {
+    'pascal-case-declarations': true,
+    'namespace-version': true
+  }
+};
+```
+---
+### Adjusting Rule Severity
+
+You can customize the severity level of each rule to control how violations are reported.  
+- **0** = error (must be fixed)  
+- **1** = warn (should be addressed)  
+- **2** = info (useful information)  
+- **3** = hint (optional suggestion)  
+
+**YAML (.spectral.yaml)**
+```yaml
+extends: '@accordproject/concerto-linter-default-ruleset'
+rules:
+  pascal-case-declarations: 'warn'  # Change from error to warning
+  camel-case-properties: 'info'     # Change to informational
+```
+
+**JSON (.spectral.json)**
+```json
+{
+  "extends": "@accordproject/concerto-linter-default-ruleset",
+  "rules": {
+    "pascal-case-declarations": "warn",
+    "camel-case-properties": "info"
+  }
+}
+```
+
+**JavaScript (.spectral.js)**
+```javascript
+const rules = require('@accordproject/concerto-linter-default-ruleset');
+module.exports = {
+  extends: rules,
+  rules: {
+    'pascal-case-declarations': 'warn',
+    'camel-case-properties': 'info'
+  }
+};
+```
+
+## Creating Custom Rules
+
+Whether you want to add new rules to the default ruleset or create an entirely new ruleset, you can follow the Spectral ruleset format. For comprehensive documentation, see the [Spectral ruleset documentation](https://meta.stoplight.io/docs/spectral/e5b9616d6d50c-rulesets).
+
+Here's a simple example of what a custom rule looks like:
+
+```yaml
+# description (optional): Explains what the ruleset is about.
+description: "Declaration names (scalar, enum, concept, asset, participant, transaction, event) should be PascalCase."
+
+# given (required): JSONPath expression that specifies where the rule applies.
+given: "$.models[*].declarations[*].name"
+
+# message (required): The error/warning message shown when the rule is violated.
+message: "Declaration '{{value}}' should be PascalCase (e.g. 'MyDeclaration')"
+
+# severity (optional): The level of violation.
+# 0 = error, 1 = warning, 2 = info, 3 = hint
+severity: 0
+
+# then (required): Defines what function to apply and how.
+then:
+  # function (required): The function that validates the rule.
+  function: casing
+
+  # functionOptions (optional): Extra options for the function.
+  functionOptions:
+    type: pascal
+```
+
+For more complex rules, you can create custom JavaScript functions following [Spectral ruleset documentation](https://meta.stoplight.io/docs/spectral/e5b9616d6d50c-rulesets) and import it into your rule, similar to how the built-in rules work.
+
+
+## License
+
+Accord Project source code files are made available under the Apache License, Version 2.0 (Apache-2.0), located in the LICENSE file. Accord Project documentation files are made available under the Creative Commons Attribution 4.0 International License (CC-BY-4.0).

package/dist/abstract-must-subclassed.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Rule: Abstract Must Be Subclassed
+ * ---------------------------------
+ * Ensures that every abstract declaration in the model has at least one concrete subclass.
+ * This helps prevent unused or orphaned abstract types, enforcing better model design.
+ */
+declare const _default: {
+    given: string;
+    severity: number;
+    then: {
+        function: import("@stoplight/spectral-core").IFunction;
+    };
+};
+export default _default;

package/dist/abstract-must-subclassed.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const find_abstract_declaration_1 = require("./functions/find-abstract-declaration");
+/**
+ * Rule: Abstract Must Be Subclassed
+ * ---------------------------------
+ * Ensures that every abstract declaration in the model has at least one concrete subclass.
+ * This helps prevent unused or orphaned abstract types, enforcing better model design.
+ */
+exports.default = {
+    given: '$.models[*]',
+    severity: 0, // 0 = error, 1 = warning, 2 = info, 3 = hint
+    then: {
+        function: find_abstract_declaration_1.hasConcreteSubclass,
+    },
+};
+//# sourceMappingURL=abstract-must-subclassed.js.map

package/dist/abstract-must-subclassed.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abstract-must-subclassed.js","sourceRoot":"","sources":["../src/abstract-must-subclassed.ts"],"names":[],"mappings":";;AAAA;;;;;;;;;;;;GAYG;AACH,qFAA4E;AAE5E;;;;;GAKG;AACH,kBAAe;IACX,KAAK,EAAE,aAAa;IACpB,QAAQ,EAAE,CAAC,EAAE,6CAA6C;IAC1D,IAAI,EAAE;QACF,QAAQ,EAAE,+CAAmB;KAChC;CACJ,CAAC"}

package/dist/camel-case-properties.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Rule: Camel Case Properties
+ * ---------------------------
+ * Ensures that properties of type String, Double, Integer, Long, DateTime, and Boolean
+ * are named using camelCase. This promotes consistency and readability in property naming
+ * conventions across the model.
+ */
+declare const _default: {
+    description: string;
+    given: string;
+    message: string;
+    severity: number;
+    then: {
+        function: import("@stoplight/spectral-core").RulesetFunctionWithValidator<string, import("@stoplight/spectral-functions").CasingOptions>;
+        functionOptions: {
+            type: string;
+        };
+    };
+};
+export default _default;

package/dist/camel-case-properties.js

@@ -0,0 +1,36 @@
+"use strict";
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const spectral_functions_1 = require("@stoplight/spectral-functions");
+/**
+ * Rule: Camel Case Properties
+ * ---------------------------
+ * Ensures that properties of type String, Double, Integer, Long, DateTime, and Boolean
+ * are named using camelCase. This promotes consistency and readability in property naming
+ * conventions across the model.
+ */
+exports.default = {
+    description: 'Properties of type String, Double, Integer, Long, DateTime, Boolean should be camelCase.',
+    given: '$.models[*].declarations[?(@.$class && @.$class != "concerto.metamodel@1.0.0.EnumDeclaration")].properties[*].name',
+    message: 'Property \'{{value}}\' should be camelCase (e.g. \'myProperty\')',
+    severity: 0, // 0 = error, 1 = warning, 2 = info, 3 = hint
+    then: {
+        function: spectral_functions_1.casing,
+        functionOptions: {
+            type: 'camel',
+        },
+    },
+};
+//# sourceMappingURL=camel-case-properties.js.map

package/dist/camel-case-properties.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"camel-case-properties.js","sourceRoot":"","sources":["../src/camel-case-properties.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;AAEH,sEAAuD;AAEvD;;;;;;GAMG;AACH,kBAAe;IACX,WAAW,EAAE,0FAA0F;IACvG,KAAK,EAAE,oHAAoH;IAC3H,OAAO,EAAE,kEAAkE;IAC3E,QAAQ,EAAE,CAAC,EAAE,6CAA6C;IAC1D,IAAI,EAAE;QACF,QAAQ,EAAE,2BAAM;QAChB,eAAe,EAAE;YACb,IAAI,EAAE,OAAO;SAChB;KACJ;CACJ,CAAC"}

package/dist/functions/check-length-validator.d.ts

@@ -0,0 +1,9 @@
+import type { IFunction } from '@stoplight/spectral-core';
+/**
+ * Checks if a String object has a length validator.
+ *
+ * @param {unknown} targetVal The AST node to check, expected to be a StringProperty or StringScalar object.
+ * @returns {IFunctionResult[] | void} An array of results indicating declarations that lack a length validator.
+ * @throws {Error} If the input is not a valid object.
+ */
+export declare const checkLengthValidator: IFunction;

package/dist/functions/check-length-validator.js

@@ -0,0 +1,40 @@
+"use strict";
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkLengthValidator = void 0;
+/**
+ * Checks if a String object has a length validator.
+ *
+ * @param {unknown} targetVal The AST node to check, expected to be a StringProperty or StringScalar object.
+ * @returns {IFunctionResult[] | void} An array of results indicating declarations that lack a length validator.
+ * @throws {Error} If the input is not a valid object.
+ */
+const checkLengthValidator = (targetVal) => {
+    // Validate that targetVal is a non-null object
+    if (targetVal === null || typeof targetVal !== 'object') {
+        throw new Error('Input must be a valid String AST object.');
+    }
+    const stringObject = targetVal;
+    const results = [];
+    // Check for missing length validator
+    if (!stringObject.lengthValidator) {
+        results.push({
+            message: `String '${stringObject.name}' must have a length validator.`,
+        });
+    }
+    return results;
+};
+exports.checkLengthValidator = checkLengthValidator;
+//# sourceMappingURL=check-length-validator.js.map

package/dist/functions/check-length-validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"check-length-validator.js","sourceRoot":"","sources":["../../src/functions/check-length-validator.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;AAeH;;;;;;GAMG;AACI,MAAM,oBAAoB,GAAc,CAAC,SAAS,EAAqB,EAAE;IAC5E,+CAA+C;IAC/C,IAAI,SAAS,KAAK,IAAI,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;QACtD,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;IAChE,CAAC;IAED,MAAM,YAAY,GAAG,SAAyB,CAAC;IAC/C,MAAM,OAAO,GAAsB,EAAE,CAAC;IAEtC,qCAAqC;IACrC,IAAI,CAAC,YAAY,CAAC,eAAe,EAAE,CAAC;QAChC,OAAO,CAAC,IAAI,CAAC;YACT,OAAO,EAAE,WAAW,YAAY,CAAC,IAAI,iCAAiC;SACzE,CAAC,CAAC;IACP,CAAC;IAED,OAAO,OAAO,CAAC;AACnB,CAAC,CAAC;AAjBW,QAAA,oBAAoB,wBAiB/B"}

package/dist/functions/find-abstract-declaration.d.ts

@@ -0,0 +1,13 @@
+import type { IFunction } from '@stoplight/spectral-core';
+/**
+ * Checks if each abstract declaration in the model has at least one concrete subclass.
+ *
+ * Iterates through the model's declarations, collects all abstract types,
+ * and removes any abstract type that is extended by a concrete subclass.
+ * Returns a result for each abstract type without a concrete subclass.
+ *
+ * @param {unknown} targetVal The AST model object containing declarations.
+ * @returns {IFunctionResult[] | void} An array of results for abstract declarations lacking concrete subclasses.
+ * @throws {Error} If the input is not a valid model AST.
+ */
+export declare const hasConcreteSubclass: IFunction;

package/dist/functions/find-abstract-declaration.js

@@ -0,0 +1,56 @@
+"use strict";
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasConcreteSubclass = void 0;
+/**
+ * Checks if each abstract declaration in the model has at least one concrete subclass.
+ *
+ * Iterates through the model's declarations, collects all abstract types,
+ * and removes any abstract type that is extended by a concrete subclass.
+ * Returns a result for each abstract type without a concrete subclass.
+ *
+ * @param {unknown} targetVal The AST model object containing declarations.
+ * @returns {IFunctionResult[] | void} An array of results for abstract declarations lacking concrete subclasses.
+ * @throws {Error} If the input is not a valid model AST.
+ */
+const hasConcreteSubclass = (targetVal) => {
+    const results = [];
+    // Validate that targetVal is a non-null object
+    if (typeof targetVal !== 'object' || !targetVal || !Array.isArray(targetVal.declarations)) {
+        throw new Error(`${targetVal} must be a valid AST for concerto model`);
+    }
+    const abstractNames = new Map();
+    const allDeclarations = targetVal.declarations;
+    for (const [index, decl] of allDeclarations.entries()) {
+        if (decl && decl.isAbstract && typeof decl.name === 'string') {
+            abstractNames.set(decl.name, index);
+        }
+    }
+    for (const decl of allDeclarations) {
+        if (decl && !decl.isAbstract && decl.superType && typeof decl.superType.name === 'string') {
+            abstractNames.delete(decl.superType.name);
+        }
+    }
+    if (abstractNames.size > 0) {
+        for (const [abstractName] of abstractNames) {
+            results.push({
+                message: `Abstract declaration '${abstractName}' must have concrete subclasses`,
+            });
+        }
+    }
+    return results;
+};
+exports.hasConcreteSubclass = hasConcreteSubclass;
+//# sourceMappingURL=find-abstract-declaration.js.map

package/dist/functions/find-abstract-declaration.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-abstract-declaration.js","sourceRoot":"","sources":["../../src/functions/find-abstract-declaration.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;AAcH;;;;;;;;;;GAUG;AACI,MAAM,mBAAmB,GAAc,CAC1C,SAAS,EACe,EAAE;IAC1B,MAAM,OAAO,GAAsB,EAAE,CAAC;IAEtC,+CAA+C;IAC/C,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,CAAC,SAAS,IAAI,CAAC,KAAK,CAAC,OAAO,CAAE,SAAmB,CAAC,YAAY,CAAC,EAAE,CAAC;QACnG,MAAM,IAAI,KAAK,CAAC,GAAG,SAAS,yCAAyC,CAAC,CAAC;IAC3E,CAAC;IAED,MAAM,aAAa,GAAG,IAAI,GAAG,EAAkB,CAAC;IAChD,MAAM,eAAe,GAAI,SAAmB,CAAC,YAAY,CAAC;IAE1D,KAAK,MAAM,CAAC,KAAK,EAAE,IAAI,CAAC,IAAI,eAAe,CAAC,OAAO,EAAE,EAAE,CAAC;QACpD,IAAI,IAAI,IAAI,IAAI,CAAC,UAAU,IAAI,OAAO,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YAC3D,aAAa,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QACxC,CAAC;IACL,CAAC;IAED,KAAK,MAAM,IAAI,IAAI,eAAe,EAAE,CAAC;QACjC,IAAI,IAAI,IAAI,CAAC,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,SAAS,IAAI,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;YACxF,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAC9C,CAAC;IACL,CAAC;IACD,IAAI,aAAa,CAAC,IAAI,GAAG,CAAC,EAAE,CAAC;QACzB,KAAK,MAAM,CAAC,YAAY,CAAC,IAAI,aAAa,EAAE,CAAC;YACzC,OAAO,CAAC,IAAI,CAAC;gBACT,OAAO,EAAE,yBAAyB,YAAY,iCAAiC;aAClF,CAAC,CAAC;QACP,CAAC;IACL,CAAC;IACD,OAAO,OAAO,CAAC;AACnB,CAAC,CAAC;AAhCW,QAAA,mBAAmB,uBAgC9B"}

package/dist/functions/find-empty-declarations.d.ts

@@ -0,0 +1,9 @@
+import type { IFunction } from '@stoplight/spectral-core';
+/**
+ * Finds and reports empty Concerto Declarations (i.e., declarations with no properties).
+ *
+ * @param {unknown} targetVal The AST node to check, expected to be a Concerto Declaration object.
+ * @returns {IFunctionResult[]} An array of results indicating declarations that are empty.
+ * @throws {Error} If the input is not a valid object.
+ */
+export declare const findEmptyDeclarations: IFunction;

package/dist/functions/find-empty-declarations.js

@@ -0,0 +1,45 @@
+"use strict";
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findEmptyDeclarations = void 0;
+/**
+ * Finds and reports empty Concerto Declarations (i.e., declarations with no properties).
+ *
+ * @param {unknown} targetVal The AST node to check, expected to be a Concerto Declaration object.
+ * @returns {IFunctionResult[]} An array of results indicating declarations that are empty.
+ * @throws {Error} If the input is not a valid object.
+ */
+const findEmptyDeclarations = (targetVal) => {
+    const results = [];
+    // Validate that targetVal is a non-null object
+    if (typeof targetVal !== 'object' || targetVal === null) {
+        throw new Error('Value must be a valid AST object for a Concerto Declaration.');
+    }
+    // Ensure targetVal is a Declaration with a 'properties' field (not a scalar)
+    if (!targetVal.properties) {
+        return results;
+    }
+    const declaration = targetVal;
+    const properties = declaration.properties;
+    // If 'properties' is missing, not an array, or empty, report an error
+    if (!Array.isArray(properties) || properties.length === 0) {
+        results.push({
+            message: `Declaration '${declaration.name}' should not be empty and must declare at least one property.`,
+        });
+    }
+    return results;
+};
+exports.findEmptyDeclarations = findEmptyDeclarations;
+//# sourceMappingURL=find-empty-declarations.js.map

package/dist/functions/find-empty-declarations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-empty-declarations.js","sourceRoot":"","sources":["../../src/functions/find-empty-declarations.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;AASH;;;;;;GAMG;AACI,MAAM,qBAAqB,GAAc,CAC5C,SAAS,EACQ,EAAE;IACnB,MAAM,OAAO,GAAsB,EAAE,CAAC;IAEtC,+CAA+C;IAC/C,IAAI,OAAO,SAAS,KAAK,QAAQ,IAAI,SAAS,KAAK,IAAI,EAAE,CAAC;QACtD,MAAM,IAAI,KAAK,CAAC,8DAA8D,CAAC,CAAC;IACpF,CAAC;IAED,6EAA6E;IAC7E,IAAI,CAAE,SAAyB,CAAC,UAAU,EAC1C,CAAC;QACG,OAAO,OAAO,CAAC;IACnB,CAAC;IAED,MAAM,WAAW,GAAG,SAAwB,CAAC;IAC7C,MAAM,UAAU,GAAG,WAAW,CAAC,UAAU,CAAC;IAE1C,sEAAsE;IACtE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACxD,OAAO,CAAC,IAAI,CAAC;YACT,OAAO,EAAE,gBAAgB,WAAW,CAAC,IAAI,+DAA+D;SAC3G,CAAC,CAAC;IACP,CAAC;IAED,OAAO,OAAO,CAAC;AACnB,CAAC,CAAC;AA3BW,QAAA,qBAAqB,yBA2BhC"}