@sdk-it/spec 0.31.0 → 0.31.2

package/dist/lib/pagination/pagination-result.test.js

@@ -1,548 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, test } from "node:test";
-import { getItemsName } from "./pagination-result.ts";
-function createSchema(properties) {
-  return properties;
-}
-function arraySchema(items) {
-  return {
-    type: "array",
-    items: items ?? { type: "object" }
-  };
-}
-function stringSchema() {
-  return {
-    type: "string"
-  };
-}
-function objectSchema(properties) {
-  return {
-    type: "object",
-    properties: properties ?? {}
-  };
-}
-describe("getItemsName()", () => {
-  describe("No Array Properties", () => {
-    test("should return null if no properties are arrays", () => {
-      const schema = createSchema({
-        name: stringSchema(),
-        age: { type: "integer" },
-        details: objectSchema()
-      });
-      assert.strictEqual(getItemsName(schema), null);
-    });
-  });
-  describe("Single Array Property", () => {
-    test("should return the name of the single array property", () => {
-      const schema = createSchema({
-        users: arraySchema(),
-        count: { type: "integer" }
-      });
-      assert.strictEqual(getItemsName(schema), "users");
-    });
-    test("should return the name even if other non-array properties exist", () => {
-      const schema = createSchema({
-        id: stringSchema(),
-        itemsList: arraySchema(),
-        metadata: objectSchema()
-      });
-      assert.strictEqual(getItemsName(schema), "itemsList");
-    });
-  });
-  describe("Multiple Array Properties - Keyword Heuristics", () => {
-    test("should prefer primary top-tier keywords (data)", () => {
-      const schema = createSchema({
-        users: arraySchema(),
-        data: arraySchema(),
-        records: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema), "data");
-    });
-    test("should prefer primary top-tier keywords (items)", () => {
-      const schema = createSchema({
-        elements: arraySchema(),
-        items: arraySchema(),
-        values: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema), "items");
-    });
-    test("should prefer primary top-tier keywords (results)", () => {
-      const schema = createSchema({
-        list: arraySchema(),
-        results: arraySchema(),
-        // Primary top-tier
-        entries: arraySchema()
-        // Secondary
-      });
-      assert.strictEqual(getItemsName(schema), "results");
-    });
-    test("should prefer primary top-tier keywords (value) - case insensitive", () => {
-      const schema = createSchema({
-        Value: arraySchema(),
-        otherArray: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema), "Value");
-    });
-    test("should prefer primary other keywords (records) if no top-tier", () => {
-      const schema = createSchema({
-        elements: arraySchema(),
-        records: arraySchema(),
-        // Primary other
-        anotherList: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema), "records");
-    });
-    test("should prefer primary other keywords (content) - case insensitive", () => {
-      const schema = createSchema({
-        Content: arraySchema(),
-        genericList: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema), "Content");
-    });
-    test("should prefer secondary keywords (entries) if no primary", () => {
-      const schema = createSchema({
-        somePlural: arraySchema(),
-        // Will be plural, but 'entries' is keyword
-        entries: arraySchema(),
-        // Secondary
-        anotherPlural: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema), "entries");
-    });
-    test('should prefer "data" over "items" if both are top-tier (based on order in PRIMARY_TOP_TIER_KEYWORDS)', () => {
-      const schema1 = createSchema({
-        items: arraySchema(),
-        data: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema1), "items");
-      const schema2 = createSchema({
-        data: arraySchema(),
-        items: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema2), "data");
-    });
-    test('should prefer "items" (rank 2) over "records" (rank 3)', () => {
-      const schema = createSchema({
-        records: arraySchema(),
-        items: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema), "items");
-    });
-    test('should prefer "records" (rank 3) over "entries" (rank 4)', () => {
-      const schema = createSchema({
-        entries: arraySchema(),
-        records: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema), "records");
-    });
-  });
-  describe("Multiple Array Properties - Pluralization Heuristics", () => {
-    test("should prefer a non-deprioritized plural over a non-keyword singular", () => {
-      const schema = createSchema({
-        products: arraySchema(),
-        // Plural, not deprioritized
-        detail: arraySchema(),
-        // Singular
-        info: arraySchema()
-        // Singular
-      });
-      assert.strictEqual(getItemsName(schema), "products");
-    });
-    test("should prefer a non-deprioritized plural (users) over a deprioritized plural (details)", () => {
-      const schema = createSchema({
-        details: arraySchema(),
-        // Plural, deprioritized
-        users: arraySchema()
-        // Plural, not deprioritized
-      });
-      assert.strictEqual(getItemsName(schema), "users");
-    });
-    test('should prefer a keyword like "items" (rank 2) over a non-deprioritized plural "products" (rank 5)', () => {
-      const schema = createSchema({
-        products: arraySchema(),
-        items: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema), "items");
-    });
-    test('should prefer a non-deprioritized plural "orders" (rank 5) over a deprioritized plural "attributes" (rank 6)', () => {
-      const schema = createSchema({
-        attributes: arraySchema(),
-        orders: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema), "orders");
-    });
-    test("should pick a deprioritized plural if it is the only plural and no keywords match better", () => {
-      const schema = createSchema({
-        links: arraySchema(),
-        // Plural, deprioritized
-        singularName: arraySchema(),
-        anotherSingular: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema), "links");
-    });
-    test("should handle mixed case plurals correctly", () => {
-      const schema = createSchema({
-        Events: arraySchema(),
-        // Plural, not deprioritized
-        metaData: arraySchema()
-        // Singular
-      });
-      assert.strictEqual(getItemsName(schema), "Events");
-    });
-  });
-  describe("Fallback Behavior", () => {
-    test("should return the first array property if no heuristics match strongly", () => {
-      const schema = createSchema({
-        arrayOne: arraySchema(),
-        arrayTwo: arraySchema(),
-        arrayThree: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema), "arrayOne");
-    });
-    test("should return the first array even if others are deprioritized plurals but no better match", () => {
-      const schema = createSchema({
-        alphaList: arraySchema(),
-        // No strong signal
-        beta_links: arraySchema(),
-        // Deprioritized plural
-        gamma_series: arraySchema()
-        // Deprioritized plural
-      });
-      assert.strictEqual(getItemsName(schema), "alphaList");
-    });
-  });
-  describe("Edge Cases and Specificity", () => {
-    test("should handle properties that are not valid SchemaObjects gracefully (e.g. boolean)", () => {
-      const schema = createSchema({
-        validArray: arraySchema(),
-        invalidProp: true
-        // Not a valid SchemaObject
-      });
-      assert.strictEqual(getItemsName(schema), "validArray");
-    });
-    test("should handle properties that are null SchemaObjects gracefully", () => {
-      const schema = createSchema({
-        anotherArray: arraySchema(),
-        nullProp: null
-        // Not a valid SchemaObject
-      });
-      assert.strictEqual(getItemsName(schema), "anotherArray");
-    });
-    test("should correctly identify primary keyword even with other plausible names", () => {
-      const schema = createSchema({
-        userList: arraySchema(),
-        data: arraySchema(),
-        // Primary top-tier
-        all_users: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema), "data");
-    });
-    test('plural "status" (deprioritized) vs singular "item_list"', () => {
-      const schema1 = createSchema({
-        status: arraySchema(),
-        item_list_singular: { type: "string" }
-        // Not an array
-      });
-      assert.strictEqual(getItemsName(schema1), "status");
-      const schema2 = createSchema({
-        status: arraySchema(),
-        // deprioritized plural
-        another_singular_array: arraySchema()
-        // singular array
-      });
-      assert.strictEqual(getItemsName(schema2), "status");
-      const schema3 = createSchema({
-        another_singular_array: arraySchema(),
-        status: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema3), "status");
-    });
-    test("complex scenario with multiple heuristics", () => {
-      const schema = createSchema({
-        errors: arraySchema(),
-        // deprioritized plural (rank 6)
-        warnings: arraySchema(),
-        // deprioritized plural (rank 6)
-        payload: arraySchema(),
-        // primary other keyword (rank 3)
-        logs: arraySchema(),
-        // non-deprioritized plural (rank 5)
-        someData: arraySchema()
-        // singular
-      });
-      assert.strictEqual(getItemsName(schema), "payload");
-    });
-    test("scenario where only deprioritized plurals exist", () => {
-      const schema = createSchema({
-        errors: arraySchema(),
-        warnings: arraySchema(),
-        details: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema), "errors");
-    });
-    test("keyword that is also a deprioritized plural should get keyword rank", () => {
-      const schema = createSchema({
-        someSingular: arraySchema(),
-        users: arraySchema(),
-        // Is a PRIMARY_OTHER_KEYWORD (rank 3)
-        details: arraySchema()
-        // Is a PLURAL_DEPRIORITIZE_LIST item (rank 6)
-      });
-      assert.strictEqual(getItemsName(schema), "users");
-    });
-    test("deprioritized plural with mixed casing is correctly identified", () => {
-      const schema = createSchema({
-        someSingular: arraySchema(),
-        Errors: arraySchema(),
-        // "errors" is on deprioritize list
-        anotherSingular: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema), "Errors");
-    });
-    test("property name with leading/trailing underscores and on deprioritize list", () => {
-      const schema = createSchema({
-        _links_: arraySchema(),
-        // plural of link, "links" is on deprioritize list
-        items: arraySchema()
-        // primary top-tier keyword
-      });
-      assert.strictEqual(getItemsName(schema), "items");
-      const schema2 = createSchema({
-        _links_: arraySchema(),
-        someData: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema2), "_links_");
-    });
-    test("property name with special characters (non-alphanumeric)", () => {
-      const schema = createSchema({
-        "item-list": arraySchema(),
-        // plural, not on deprioritize list
-        "data-feed": arraySchema()
-        // singular
-      });
-      assert.strictEqual(getItemsName(schema), "item-list");
-      const schema2 = createSchema({
-        "item-list": arraySchema(),
-        data: arraySchema()
-        // keyword (rank 2)
-      });
-      assert.strictEqual(getItemsName(schema2), "data");
-    });
-    test("empty string as property name for an array", () => {
-      const schema1 = createSchema({
-        "": arraySchema(),
-        items: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema1), "items");
-      const schema2 = createSchema({
-        "": arraySchema(),
-        anotherArray: arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema2), "");
-      const schema3 = createSchema({
-        anotherArray: arraySchema(),
-        "": arraySchema()
-      });
-      assert.strictEqual(getItemsName(schema3), "anotherArray");
-    });
-  });
-  describe("Comprehensive Ranking and Order Independence", () => {
-    test("should pick top-tier keyword regardless of its order among other types", () => {
-      const schema = createSchema({
-        userActions: arraySchema(),
-        // Non-deprioritized plural (rank 5)
-        configurations: arraySchema(),
-        // Deprioritized plural (rank 6)
-        entries: arraySchema(),
-        // Secondary keyword (rank 4)
-        records: arraySchema(),
-        // Primary other keyword (rank 3)
-        data: arraySchema(),
-        // Primary top-tier keyword (rank 2)
-        someSingular: arraySchema()
-        // Singular (fallback)
-      });
-      assert.strictEqual(getItemsName(schema), "data");
-    });
-    test("should pick primary other keyword if no top-tier, regardless of order", () => {
-      const schema = createSchema({
-        userActions: arraySchema(),
-        // Non-deprioritized plural (rank 5)
-        configurations: arraySchema(),
-        // Deprioritized plural (rank 6)
-        payload: arraySchema(),
-        // Primary other keyword (rank 3)
-        entries: arraySchema(),
-        // Secondary keyword (rank 4)
-        someSingular: arraySchema()
-        // Singular (fallback)
-      });
-      assert.strictEqual(getItemsName(schema), "payload");
-    });
-    test("should pick secondary keyword if no primary, regardless of order", () => {
-      const schema = createSchema({
-        userActions: arraySchema(),
-        // Non-deprioritized plural (rank 5)
-        elements: arraySchema(),
-        // Secondary keyword (rank 4)
-        configurations: arraySchema(),
-        // Deprioritized plural (rank 6)
-        someSingular: arraySchema()
-        // Singular (fallback)
-      });
-      assert.strictEqual(getItemsName(schema), "elements");
-    });
-    test("should pick non-deprioritized plural if no keywords, regardless of order", () => {
-      const schema = createSchema({
-        configurations: arraySchema(),
-        // Deprioritized plural (rank 6)
-        userActions: arraySchema(),
-        // Non-deprioritized plural (rank 5)
-        someSingular: arraySchema()
-        // Singular (fallback)
-      });
-      assert.strictEqual(getItemsName(schema), "userActions");
-    });
-    test("should pick deprioritized plural if only that and singulars, regardless of order", () => {
-      const schema = createSchema({
-        someSingular: arraySchema(),
-        // Singular (fallback)
-        configurations: arraySchema(),
-        // Deprioritized plural (rank 6)
-        anotherSingular: arraySchema()
-        // Singular (fallback)
-      });
-      assert.strictEqual(getItemsName(schema), "configurations");
-    });
-    test("if multiple properties have the same highest rank, first one is chosen", () => {
-      const schema1 = createSchema({
-        data: arraySchema(),
-        // rank 2
-        items: arraySchema(),
-        // rank 2
-        results: arraySchema()
-        // rank 2
-      });
-      assert.strictEqual(getItemsName(schema1), "data");
-      const schema2 = createSchema({
-        items: arraySchema(),
-        // rank 2
-        data: arraySchema()
-        // rank 2
-      });
-      assert.strictEqual(getItemsName(schema2), "items");
-      const schema3 = createSchema({
-        goodPlural: arraySchema(),
-        // rank 5
-        anotherGoodPlural: arraySchema()
-        // rank 5
-      });
-      assert.strictEqual(getItemsName(schema3), "goodPlural");
-    });
-    test('singular name on deprioritize list (e.g. "status") is treated as singular if not plural', () => {
-      const schema1 = createSchema({
-        status: arraySchema(),
-        // Singular
-        another: arraySchema()
-        // Singular
-      });
-      assert.strictEqual(getItemsName(schema1), "status");
-      const schema2 = createSchema({
-        another: arraySchema(),
-        // Singular
-        status: arraySchema()
-        // Singular
-      });
-      assert.strictEqual(getItemsName(schema2), "another");
-      const schema3 = createSchema({
-        status: arraySchema(),
-        // Singular
-        items: arraySchema()
-        // Keyword, rank 2
-      });
-      assert.strictEqual(getItemsName(schema3), "items");
-      const schema4 = createSchema({
-        status: arraySchema(),
-        // Singular
-        statuses: arraySchema()
-        // Plural (non-deprioritized as "statuses" is not on list), rank 5
-      });
-      assert.strictEqual(getItemsName(schema4), "statuses");
-    });
-    test("a keyword should be preferred over a non-keyword plural even if plural comes first", () => {
-      const schema = createSchema({
-        products: arraySchema(),
-        // Non-keyword plural (rank 5)
-        data: arraySchema()
-        // Primary top-tier keyword (rank 2)
-      });
-      assert.strictEqual(getItemsName(schema), "data");
-    });
-    test("full spectrum ranking test with specific order", () => {
-      const schema = createSchema({
-        alpha: arraySchema(),
-        // Singular fallback
-        zeta_errors: arraySchema(),
-        // Deprioritized plural (rank 6) "errors"
-        beta_actions: arraySchema(),
-        // Non-deprioritized plural (rank 5) "actions" (assuming not on deprioritize list for this test)
-        gamma_elements: arraySchema(),
-        // Secondary keyword (rank 4) "elements"
-        delta_records: arraySchema(),
-        // Primary other keyword (rank 3) "records"
-        epsilon_items: arraySchema()
-        // Primary top-tier keyword (rank 2) "items"
-      });
-      assert.strictEqual(
-        getItemsName(schema),
-        "epsilon_items",
-        "Failed with specific order 1"
-      );
-      const schema2 = createSchema({
-        epsilon_items: arraySchema(),
-        // Rank 2
-        delta_records: arraySchema(),
-        // Rank 3
-        gamma_elements: arraySchema(),
-        // Rank 4
-        beta_actions: arraySchema(),
-        // Rank 5
-        zeta_errors: arraySchema(),
-        // Rank 6
-        alpha: arraySchema()
-        // Fallback
-      });
-      assert.strictEqual(
-        getItemsName(schema2),
-        "epsilon_items",
-        "Failed with specific order 2 (reversed)"
-      );
-    });
-    test("ensure singular items from PLURAL_DEPRIORITIZE_LIST are not ranked as plural", () => {
-      const schema = createSchema({
-        status: arraySchema(),
-        // Singular, not plural. Fallback.
-        items: arraySchema(),
-        // Keyword, rank 2.
-        logs: arraySchema()
-        // Plural, not on deprioritize list. Rank 5.
-      });
-      assert.strictEqual(getItemsName(schema), "items");
-      const schema2 = createSchema({
-        status: arraySchema(),
-        // Singular
-        logs: arraySchema()
-        // Plural, rank 5
-      });
-      assert.strictEqual(getItemsName(schema2), "logs");
-      const schema3 = createSchema({
-        status: arraySchema(),
-        // Singular
-        another_singular: arraySchema()
-        // Singular
-      });
-      assert.strictEqual(getItemsName(schema3), "status");
-    });
-  });
-});
-//# sourceMappingURL=pagination-result.test.js.map

package/dist/lib/pagination/pagination-result.test.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../../src/lib/pagination/pagination-result.test.ts"],
-  "sourcesContent": ["import assert from 'node:assert/strict';\nimport { describe, test } from 'node:test';\nimport type { SchemaObject, SchemasObject } from 'openapi3-ts/oas31';\n\nimport { getItemsName } from './pagination-result.ts';\n\nfunction createSchema(properties: SchemasObject) {\n  return properties;\n}\n\nfunction arraySchema(items?: SchemaObject): SchemaObject {\n  return {\n    type: 'array',\n    items: items ?? { type: 'object' },\n  };\n}\n\nfunction stringSchema(): SchemaObject {\n  return {\n    type: 'string',\n  };\n}\n\nfunction objectSchema(properties?: SchemasObject): SchemaObject {\n  return {\n    type: 'object',\n    properties: properties ?? {},\n  };\n}\n\ndescribe('getItemsName()', () => {\n  describe('No Array Properties', () => {\n    test('should return null if no properties are arrays', () => {\n      const schema = createSchema({\n        name: stringSchema(),\n        age: { type: 'integer' },\n        details: objectSchema(),\n      });\n      assert.strictEqual(getItemsName(schema), null);\n    });\n  });\n\n  describe('Single Array Property', () => {\n    test('should return the name of the single array property', () => {\n      const schema = createSchema({\n        users: arraySchema(),\n        count: { type: 'integer' },\n      });\n      assert.strictEqual(getItemsName(schema), 'users');\n    });\n\n    test('should return the name even if other non-array properties exist', () => {\n      const schema = createSchema({\n        id: stringSchema(),\n        itemsList: arraySchema(),\n        metadata: objectSchema(),\n      });\n      assert.strictEqual(getItemsName(schema), 'itemsList');\n    });\n  });\n\n  describe('Multiple Array Properties - Keyword Heuristics', () => {\n    test('should prefer primary top-tier keywords (data)', () => {\n      const schema = createSchema({\n        users: arraySchema(),\n        data: arraySchema(),\n        records: arraySchema(),\n      });\n      assert.strictEqual(getItemsName(schema), 'data');\n    });\n\n    test('should prefer primary top-tier keywords (items)', () => {\n      const schema = createSchema({\n        elements: arraySchema(),\n        items: arraySchema(),\n        values: arraySchema(),\n      });\n      assert.strictEqual(getItemsName(schema), 'items');\n    });\n\n    test('should prefer primary top-tier keywords (results)', () => {\n      const schema = createSchema({\n        list: arraySchema(),\n        results: arraySchema(), // Primary top-tier\n        entries: arraySchema(), // Secondary\n      });\n      assert.strictEqual(getItemsName(schema), 'results');\n    });\n\n    test('should prefer primary top-tier keywords (value) - case insensitive', () => {\n      const schema = createSchema({\n        Value: arraySchema(),\n        otherArray: arraySchema(),\n      });\n      assert.strictEqual(getItemsName(schema), 'Value');\n    });\n\n    test('should prefer primary other keywords (records) if no top-tier', () => {\n      const schema = createSchema({\n        elements: arraySchema(),\n        records: arraySchema(), // Primary other\n        anotherList: arraySchema(),\n      });\n      assert.strictEqual(getItemsName(schema), 'records');\n    });\n\n    test('should prefer primary other keywords (content) - case insensitive', () => {\n      const schema = createSchema({\n        Content: arraySchema(),\n        genericList: arraySchema(),\n      });\n      assert.strictEqual(getItemsName(schema), 'Content');\n    });\n\n    test('should prefer secondary keywords (entries) if no primary', () => {\n      const schema = createSchema({\n        somePlural: arraySchema(), // Will be plural, but 'entries' is keyword\n        entries: arraySchema(), // Secondary\n        anotherPlural: arraySchema(),\n      });\n      assert.strictEqual(getItemsName(schema), 'entries');\n    });\n\n    test('should prefer \"data\" over \"items\" if both are top-tier (based on order in PRIMARY_TOP_TIER_KEYWORDS)', () => {\n      // This test assumes internal stability of PRIMARY_TOP_TIER_KEYWORDS or that the first match wins.\n      // The current implementation iterates and updates if a *better* rank is found.\n      // If 'data' and 'items' have the same rank (2), the one encountered first as per property order might win.\n      // Let's test specific ordering.\n      const schema1 = createSchema({\n        items: arraySchema(),\n        data: arraySchema(),\n      });\n      assert.strictEqual(getItemsName(schema1), 'items'); // 'items' comes first in schema\n\n      const schema2 = createSchema({\n        data: arraySchema(),\n        items: arraySchema(),\n      });\n      assert.strictEqual(getItemsName(schema2), 'data'); // 'data' comes first in schema\n    });\n\n    test('should prefer \"items\" (rank 2) over \"records\" (rank 3)', () => {\n      const schema = createSchema({\n        records: arraySchema(),\n        items: arraySchema(),\n      });\n      assert.strictEqual(getItemsName(schema), 'items');\n    });\n\n    test('should prefer \"records\" (rank 3) over \"entries\" (rank 4)', () => {\n      const schema = createSchema({\n        entries: arraySchema(),\n        records: arraySchema(),\n      });\n      assert.strictEqual(getItemsName(schema), 'records');\n    });\n  });\n\n  describe('Multiple Array Properties - Pluralization Heuristics', () => {\n    test('should prefer a non-deprioritized plural over a non-keyword singular', () => {\n      const schema = createSchema({\n        products: arraySchema(), // Plural, not deprioritized\n        detail: arraySchema(), // Singular\n        info: arraySchema(), // Singular\n      });\n      assert.strictEqual(getItemsName(schema), 'products');\n    });\n\n    test('should prefer a non-deprioritized plural (users) over a deprioritized plural (details)', () => {\n      const schema = createSchema({\n        details: arraySchema(), // Plural, deprioritized\n        users: arraySchema(), // Plural, not deprioritized\n      });\n      assert.strictEqual(getItemsName(schema), 'users');\n    });\n\n    test('should prefer a keyword like \"items\" (rank 2) over a non-deprioritized plural \"products\" (rank 5)', () => {\n      const schema = createSchema({\n        products: arraySchema(),\n        items: arraySchema(),\n      });\n      assert.strictEqual(getItemsName(schema), 'items');\n    });\n\n    test('should prefer a non-deprioritized plural \"orders\" (rank 5) over a deprioritized plural \"attributes\" (rank 6)', () => {\n      const schema = createSchema({\n        attributes: arraySchema(),\n        orders: arraySchema(),\n      });\n      assert.strictEqual(getItemsName(schema), 'orders');\n    });\n\n    test('should pick a deprioritized plural if it is the only plural and no keywords match better', () => {\n      const schema = createSchema({\n        links: arraySchema(), // Plural, deprioritized\n        singularName: arraySchema(),\n        anotherSingular: arraySchema(),\n      });\n      assert.strictEqual(getItemsName(schema), 'links');\n    });\n\n    test('should handle mixed case plurals correctly', () => {\n      const schema = createSchema({\n        Events: arraySchema(), // Plural, not deprioritized\n        metaData: arraySchema(), // Singular\n      });\n      assert.strictEqual(getItemsName(schema), 'Events');\n    });\n  });\n\n  describe('Fallback Behavior', () => {\n    test('should return the first array property if no heuristics match strongly', () => {\n      const schema = createSchema({\n        arrayOne: arraySchema(),\n        arrayTwo: arraySchema(),\n        arrayThree: arraySchema(),\n      });\n      assert.strictEqual(getItemsName(schema), 'arrayOne');\n    });\n\n    test('should return the first array even if others are deprioritized plurals but no better match', () => {\n      const schema = createSchema({\n        alphaList: arraySchema(), // No strong signal\n        beta_links: arraySchema(), // Deprioritized plural\n        gamma_series: arraySchema(), // Deprioritized plural\n      });\n      assert.strictEqual(getItemsName(schema), 'alphaList'); // Falls back to first\n    });\n  });\n\n  describe('Edge Cases and Specificity', () => {\n    test('should handle properties that are not valid SchemaObjects gracefully (e.g. boolean)', () => {\n      const schema = createSchema({\n        validArray: arraySchema(),\n        invalidProp: true as never, // Not a valid SchemaObject\n      });\n      assert.strictEqual(getItemsName(schema), 'validArray');\n    });\n\n    test('should handle properties that are null SchemaObjects gracefully', () => {\n      const schema = createSchema({\n        anotherArray: arraySchema(),\n        nullProp: null as never, // Not a valid SchemaObject\n      });\n      assert.strictEqual(getItemsName(schema), 'anotherArray');\n    });\n\n    test('should correctly identify primary keyword even with other plausible names', () => {\n      const schema = createSchema({\n        userList: arraySchema(),\n        data: arraySchema(), // Primary top-tier\n        all_users: arraySchema(),\n      });\n      assert.strictEqual(getItemsName(schema), 'data');\n    });\n\n    test('plural \"status\" (deprioritized) vs singular \"item_list\"', () => {\n      // 'status' is plural but on deprioritize list (rank 6)\n      // 'item_list' is singular (no rank from pluralization)\n      // Fallback should pick 'status' if it's the only plural or first among equals.\n      // However, if 'item_list' is the only array, it should be picked.\n      const schema1 = createSchema({\n        status: arraySchema(),\n        item_list_singular: { type: 'string' }, // Not an array\n      });\n      assert.strictEqual(getItemsName(schema1), 'status');\n\n      const schema2 = createSchema({\n        status: arraySchema(), // deprioritized plural\n        another_singular_array: arraySchema(), // singular array\n      });\n      // 'status' (rank 6) vs 'another_singular_array' (no rank from plural, default to first if no other match)\n      // The current logic would make 'status' rank 6. 'another_singular_array' would be rank Infinity initially.\n      // Then, if no other heuristics match, it falls back to the first array.\n      // If 'status' is first, it wins. If 'another_singular_array' is first, it wins.\n      // Let's test order.\n      assert.strictEqual(getItemsName(schema2), 'status'); // 'status' is rank 6, 'another_singular_array' is effectively rank > 6\n\n      const schema3 = createSchema({\n        another_singular_array: arraySchema(),\n        status: arraySchema(),\n      });\n      assert.strictEqual(getItemsName(schema3), 'status'); // 'status' (rank 6) should still be preferred over 'another_singular_array' (rank > 6)\n    });\n\n    test('complex scenario with multiple heuristics', () => {\n      const schema = createSchema({\n        errors: arraySchema(), // deprioritized plural (rank 6)\n        warnings: arraySchema(), // deprioritized plural (rank 6)\n        payload: arraySchema(), // primary other keyword (rank 3)\n        logs: arraySchema(), // non-deprioritized plural (rank 5)\n        someData: arraySchema(), // singular\n      });\n      assert.strictEqual(getItemsName(schema), 'payload');\n    });\n\n    test('scenario where only deprioritized plurals exist', () => {\n      const schema = createSchema({\n        errors: arraySchema(),\n        warnings: arraySchema(),\n        details: arraySchema(),\n      });\n      // All are rank 6. The first one encountered should be returned.\n      assert.strictEqual(getItemsName(schema), 'errors');\n    });\n\n    test('keyword that is also a deprioritized plural should get keyword rank', () => {\n      // \"errors\" is on PLURAL_DEPRIORITIZE_LIST (would be rank 6)\n      // If \"errors\" was also a secondary keyword (rank 4), it should be chosen with rank 4.\n      // This test relies on the internal keyword lists or would need to mock them.\n      // For now, let's use an existing keyword that is plural: \"users\" is in PRIMARY_OTHER_KEYWORDS (rank 3).\n      // If \"users\" were (hypothetically) also on PLURAL_DEPRIORITIZE_LIST, it should still be rank 3.\n      const schema = createSchema({\n        someSingular: arraySchema(),\n        users: arraySchema(), // Is a PRIMARY_OTHER_KEYWORD (rank 3)\n        details: arraySchema(), // Is a PLURAL_DEPRIORITIZE_LIST item (rank 6)\n      });\n      // \"users\" (rank 3) should win over \"details\" (rank 6) and \"someSingular\" (fallback)\n      assert.strictEqual(getItemsName(schema), 'users');\n    });\n\n    test('deprioritized plural with mixed casing is correctly identified', () => {\n      const schema = createSchema({\n        someSingular: arraySchema(),\n        Errors: arraySchema(), // \"errors\" is on deprioritize list\n        anotherSingular: arraySchema(),\n      });\n      // \"Errors\" (rank 6) should be chosen over singulars (fallback)\n      assert.strictEqual(getItemsName(schema), 'Errors');\n    });\n\n    test('property name with leading/trailing underscores and on deprioritize list', () => {\n      const schema = createSchema({\n        _links_: arraySchema(), // plural of link, \"links\" is on deprioritize list\n        items: arraySchema(), // primary top-tier keyword\n      });\n      // \"items\" (rank 2) should win over \"_links_\" (rank 6)\n      assert.strictEqual(getItemsName(schema), 'items');\n\n      const schema2 = createSchema({\n        _links_: arraySchema(),\n        someData: arraySchema(),\n      });\n      assert.strictEqual(getItemsName(schema2), '_links_');\n    });\n\n    test('property name with special characters (non-alphanumeric)', () => {\n      const schema = createSchema({\n        'item-list': arraySchema(), // plural, not on deprioritize list\n        'data-feed': arraySchema(), // singular\n      });\n      // 'item-list' (rank 5) vs 'data-feed' (fallback)\n      assert.strictEqual(getItemsName(schema), 'item-list');\n\n      const schema2 = createSchema({\n        'item-list': arraySchema(),\n        data: arraySchema(), // keyword (rank 2)\n      });\n      assert.strictEqual(getItemsName(schema2), 'data');\n    });\n\n    test('empty string as property name for an array', () => {\n      const schema1 = createSchema({\n        '': arraySchema(),\n        items: arraySchema(),\n      });\n      // \"items\" (rank 2) should win over \"\" (would be rank 5 if considered plural, or fallback)\n      assert.strictEqual(getItemsName(schema1), 'items');\n\n      const schema2 = createSchema({\n        '': arraySchema(),\n        anotherArray: arraySchema(),\n      });\n      // \"\" is plural (empty string is technically pluralized to \"s\" by some libraries,\n      // but pluralize.isPlural('') is false). So it's a fallback.\n      // The first one, \"\", should be chosen.\n      assert.strictEqual(getItemsName(schema2), '');\n\n      const schema3 = createSchema({\n        anotherArray: arraySchema(),\n        '': arraySchema(),\n      });\n      assert.strictEqual(getItemsName(schema3), 'anotherArray');\n    });\n  });\n\n  describe('Comprehensive Ranking and Order Independence', () => {\n    test('should pick top-tier keyword regardless of its order among other types', () => {\n      const schema = createSchema({\n        userActions: arraySchema(), // Non-deprioritized plural (rank 5)\n        configurations: arraySchema(), // Deprioritized plural (rank 6)\n        entries: arraySchema(), // Secondary keyword (rank 4)\n        records: arraySchema(), // Primary other keyword (rank 3)\n        data: arraySchema(), // Primary top-tier keyword (rank 2)\n        someSingular: arraySchema(), // Singular (fallback)\n      });\n      assert.strictEqual(getItemsName(schema), 'data');\n    });\n\n    test('should pick primary other keyword if no top-tier, regardless of order', () => {\n      const schema = createSchema({\n        userActions: arraySchema(), // Non-deprioritized plural (rank 5)\n        configurations: arraySchema(), // Deprioritized plural (rank 6)\n        payload: arraySchema(), // Primary other keyword (rank 3)\n        entries: arraySchema(), // Secondary keyword (rank 4)\n        someSingular: arraySchema(), // Singular (fallback)\n      });\n      assert.strictEqual(getItemsName(schema), 'payload');\n    });\n\n    test('should pick secondary keyword if no primary, regardless of order', () => {\n      const schema = createSchema({\n        userActions: arraySchema(), // Non-deprioritized plural (rank 5)\n        elements: arraySchema(), // Secondary keyword (rank 4)\n        configurations: arraySchema(), // Deprioritized plural (rank 6)\n        someSingular: arraySchema(), // Singular (fallback)\n      });\n      assert.strictEqual(getItemsName(schema), 'elements');\n    });\n\n    test('should pick non-deprioritized plural if no keywords, regardless of order', () => {\n      const schema = createSchema({\n        configurations: arraySchema(), // Deprioritized plural (rank 6)\n        userActions: arraySchema(), // Non-deprioritized plural (rank 5)\n        someSingular: arraySchema(), // Singular (fallback)\n      });\n      assert.strictEqual(getItemsName(schema), 'userActions');\n    });\n\n    test('should pick deprioritized plural if only that and singulars, regardless of order', () => {\n      const schema = createSchema({\n        someSingular: arraySchema(), // Singular (fallback)\n        configurations: arraySchema(), // Deprioritized plural (rank 6)\n        anotherSingular: arraySchema(), // Singular (fallback)\n      });\n      assert.strictEqual(getItemsName(schema), 'configurations');\n    });\n\n    test('if multiple properties have the same highest rank, first one is chosen', () => {\n      const schema1 = createSchema({\n        data: arraySchema(), // rank 2\n        items: arraySchema(), // rank 2\n        results: arraySchema(), // rank 2\n      });\n      assert.strictEqual(getItemsName(schema1), 'data');\n\n      const schema2 = createSchema({\n        items: arraySchema(), // rank 2\n        data: arraySchema(), // rank 2\n      });\n      assert.strictEqual(getItemsName(schema2), 'items');\n\n      const schema3 = createSchema({\n        goodPlural: arraySchema(), // rank 5\n        anotherGoodPlural: arraySchema(), // rank 5\n      });\n      assert.strictEqual(getItemsName(schema3), 'goodPlural');\n    });\n\n    test('singular name on deprioritize list (e.g. \"status\") is treated as singular if not plural', () => {\n      // 'status' is singular, pluralize.isPlural('status') is false.\n      // So it doesn't get rank 6 from being a deprioritized plural.\n      // It's just a regular singular name.\n      const schema1 = createSchema({\n        status: arraySchema(), // Singular\n        another: arraySchema(), // Singular\n      });\n      assert.strictEqual(getItemsName(schema1), 'status'); // Fallback to first\n\n      const schema2 = createSchema({\n        another: arraySchema(), // Singular\n        status: arraySchema(), // Singular\n      });\n      assert.strictEqual(getItemsName(schema2), 'another'); // Fallback to first\n\n      const schema3 = createSchema({\n        status: arraySchema(), // Singular\n        items: arraySchema(), // Keyword, rank 2\n      });\n      assert.strictEqual(getItemsName(schema3), 'items');\n\n      const schema4 = createSchema({\n        status: arraySchema(), // Singular\n        statuses: arraySchema(), // Plural (non-deprioritized as \"statuses\" is not on list), rank 5\n      });\n      // \"statuses\" (rank 5) vs \"status\" (no rank, fallback)\n      assert.strictEqual(getItemsName(schema4), 'statuses');\n    });\n\n    test('a keyword should be preferred over a non-keyword plural even if plural comes first', () => {\n      const schema = createSchema({\n        products: arraySchema(), // Non-keyword plural (rank 5)\n        data: arraySchema(), // Primary top-tier keyword (rank 2)\n      });\n      assert.strictEqual(getItemsName(schema), 'data');\n    });\n\n    test('full spectrum ranking test with specific order', () => {\n      const schema = createSchema({\n        alpha: arraySchema(), // Singular fallback\n        zeta_errors: arraySchema(), // Deprioritized plural (rank 6) \"errors\"\n        beta_actions: arraySchema(), // Non-deprioritized plural (rank 5) \"actions\" (assuming not on deprioritize list for this test)\n        gamma_elements: arraySchema(), // Secondary keyword (rank 4) \"elements\"\n        delta_records: arraySchema(), // Primary other keyword (rank 3) \"records\"\n        epsilon_items: arraySchema(), // Primary top-tier keyword (rank 2) \"items\"\n      });\n      assert.strictEqual(\n        getItemsName(schema),\n        'epsilon_items',\n        'Failed with specific order 1',\n      );\n\n      const schema2 = createSchema({\n        epsilon_items: arraySchema(), // Rank 2\n        delta_records: arraySchema(), // Rank 3\n        gamma_elements: arraySchema(), // Rank 4\n        beta_actions: arraySchema(), // Rank 5\n        zeta_errors: arraySchema(), // Rank 6\n        alpha: arraySchema(), // Fallback\n      });\n      assert.strictEqual(\n        getItemsName(schema2),\n        'epsilon_items',\n        'Failed with specific order 2 (reversed)',\n      );\n    });\n\n    test('ensure singular items from PLURAL_DEPRIORITIZE_LIST are not ranked as plural', () => {\n      // \"status\" is on PLURAL_DEPRIORITIZE_LIST, but singular \"status\" is not plural.\n      const schema = createSchema({\n        status: arraySchema(), // Singular, not plural. Fallback.\n        items: arraySchema(), // Keyword, rank 2.\n        logs: arraySchema(), // Plural, not on deprioritize list. Rank 5.\n      });\n      assert.strictEqual(getItemsName(schema), 'items');\n\n      const schema2 = createSchema({\n        status: arraySchema(), // Singular\n        logs: arraySchema(), // Plural, rank 5\n      });\n      assert.strictEqual(getItemsName(schema2), 'logs');\n\n      const schema3 = createSchema({\n        status: arraySchema(), // Singular\n        another_singular: arraySchema(), // Singular\n      });\n      assert.strictEqual(getItemsName(schema3), 'status'); // Fallback to first\n    });\n  });\n});\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/lib/pagination/pagination.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=pagination.test.d.ts.map

package/dist/lib/pagination/pagination.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"pagination.test.d.ts","sourceRoot":"","sources":["../../../src/lib/pagination/pagination.test.ts"],"names":[],"mappings":""}