Download the PHP package coretsia/devtools-internal-toolkit without Composer

On this page you can find all versions of the php package coretsia/devtools-internal-toolkit. It is possible to download/install these versions without Composer. Possible dependencies are resolved automatically.

FAQ

After the download, you have to make one include require_once('vendor/autoload.php');. After that you have to import the classes with use statements.

Example:
If you use only one package a project is not needed. But if you use more then one package, without a project it is not possible to import the classes with use statements.

In general, it is recommended to use always a project to download your libraries. In an application normally there is more than one library needed.
Some PHP packages are not free to download and because of that hosted in private repositories. In this case some credentials are needed to access such packages. Please use the auth.json textarea to insert credentials, if a package is coming from a private repository. You can look here for more information.

  • Some hosting areas are not accessible by a terminal or SSH. Then it is not possible to use Composer.
  • To use Composer is sometimes complicated. Especially for beginners.
  • Composer needs much resources. Sometimes they are not available on a simple webspace.
  • If you are using private repositories you don't need to share your credentials. You can set up everything on our site and then you provide a simple download link to your team member.
  • Simplify your Composer build process. Use our own command line tool to download the vendor folder as binary. This makes your build process faster and you don't need to expose your credentials for private repositories.
Please rate this library. Is it a good library?

Informations about the package devtools-internal-toolkit

coretsia/devtools-internal-toolkit

devtools/internal-toolkit is the tooling-only deterministic helper package for Coretsia repository tooling and devtools.

Scope: small canonical primitives for stable JSON encoding, repository-relative path normalization, and deterministic identifier transformation used by Coretsia tooling, validation tooling, generators, runners, and repository automation.

Out of scope: application runtime behavior, production runtime dependencies, service-container integration, platform behavior, integrations, transport execution, runtime serialization, and general-purpose utility ownership.

Package identity

Monorepo versioning is repo-wide only via git tags vMAJOR.MINOR.PATCH.

The corresponding split repository is coretsia/devtools-internal-toolkit and receives the same tag for the package subtree.

Per-package independent versions MUST NOT be used.

Dependency policy

This package is tooling-only and intentionally small.

Coretsia publishable products outside devtools/* and consuming applications MUST NOT depend on coretsia/devtools-internal-toolkit.

If runtime code requires deterministic serialization, path handling, naming, or another similar primitive, the runtime owner package MUST provide or depend on an appropriate runtime-safe implementation instead of importing this devtools package.

The package MUST NOT become a shared miscellaneous utility layer for unrelated runtime or application behavior.

Tooling responsibilities

This package owns a deliberately narrow set of deterministic cross-cutting helpers for Coretsia tooling.

The canonical public API is:

The helper classes are:

They are final, non-instantiable, static-only helpers.

The package owns these primitives so repository tooling can share one canonical implementation instead of reproducing slightly different local variants.

Ownership boundaries

devtools/internal-toolkit owns deterministic helper behavior for Coretsia tooling only.

It does not own:

Callers own the higher-level semantics of the data they pass to these helpers.

For example:

Tooling packages MUST NOT infer broader runtime or domain semantics from these helpers.

Stable JSON

The canonical tooling JSON helper is:

Its public API is:

Json::encodeStable() produces stable JSON bytes for supported json-like tooling arrays.

Value model

Supported scalar values are:

Nested arrays are supported recursively.

Floats are forbidden, including:

Unsupported values include objects, resources, and other non-json-like PHP values.

Lists and maps

Array classification uses:

Lists preserve caller-supplied order.

Maps:

An empty PHP array is treated as a list and is encoded as:

Encoding

Encoding uses:

The helper returns JSON bytes only.

It does not append a trailing newline.

Caller-owned output code decides whether a final LF is required by the target file or artifact format.

JSON failures

A float fails with:

When the failure is nested, the structural path is appended.

Unsupported values or unsupported map keys fail with:

Again, a structural path may be appended for nested failures.

JSON encoding failures from json_encode() remain JsonException failures.

These are tooling failures, not runtime transport error contracts.

Repository-relative paths

The canonical path helper is:

Its public API is:

The helper converts an absolute or repository-relative input path into a normalized repository-relative path.

The operation is lexical and deterministic.

It does not require the input path to exist on the filesystem.

Path normalization rules

The result:

When the normalized path identifies the repository root itself, the result is:

Redundant separators and . segments are normalized.

Relative inputs are resolved lexically against the supplied repository root.

Platform handling

The helper supports canonical absolute path handling for:

Windows containment comparison follows case-insensitive Windows path semantics.

Drive letters are normalized for canonical absolute-path processing.

The output remains forward-slash repository-relative form.

Path failures

Stable path failure tokens include:

Path failures use InvalidArgumentException.

The helper MUST fail instead of returning a repository-relative path for an input that resolves outside the supplied repository root.

Identifier transformations

The canonical identifier helper is:

It provides:

The transformations are ASCII-oriented and deterministic.

They do not depend on process locale, ICU collation, filesystem casing, or locale-specific title-casing.

Studly transformation

Slug::toStudly() converts slug-like identifiers into StudlyCase.

Examples:

Non-alphanumeric separators delimit parts.

Each part is normalized with locale-independent ASCII casing.

An empty or whitespace-only input produces an empty string.

Snake transformation

Slug::toSnake() converts common identifier forms into lowercase snake_case.

Examples:

The helper:

An empty or whitespace-only input produces an empty string.

Anti-duplication boundary

These helpers are intended to be the canonical implementations for their owned tooling responsibilities.

Coretsia repository tooling MUST NOT duplicate an owned helper implementation when the canonical toolkit API already provides the required behavior.

This anti-duplication rule does not expand the package into a generic utility owner.

New helpers SHOULD be added only when there is a genuine cross-tooling invariant that benefits from one canonical deterministic implementation.

Usage

This package is consumed through Composer autoloading.

Path-based includes are not part of the supported package API.

The resulting JSON is stable for the same supported input:

Higher-level tooling remains responsible for writing files, adding final newlines where required, choosing schemas, and deciding how the resulting values are consumed.

Determinism

All owned helper operations MUST produce the same result for the same supported inputs under the same documented platform semantics.

Deterministic behavior includes:

Owned helper output MUST NOT introduce:

The helpers MUST NOT perform hidden filesystem discovery or environment inspection to determine their normal result.

Any future extension MUST preserve rerun-no-diff behavior for identical repository state and inputs.

Observability

This package does not emit telemetry.

It does not define:

Helper execution is local deterministic tooling behavior.

Higher-level tools own any user-facing reporting or diagnostics around helper invocation.

Errors

This package does not define production runtime error contracts.

Invalid helper input fails through deterministic tooling exceptions.

Current public failure classes are standard PHP exceptions:

Stable toolkit-specific reason tokens are used where the helper performs explicit validation.

These failures are intended for tooling diagnostics and automated tooling checks.

They MUST NOT be reinterpreted as application, transport, HTTP, Worker, Kernel, or other production runtime error contracts.

Callers MAY add higher-level tooling context, but MUST NOT change the deterministic semantics of the underlying helper operation.

Security / Redaction

This package is tooling-only and does not intentionally process sensitive runtime payloads.

Callers MUST NOT pass raw sensitive material into helper-produced diagnostics or generated tooling outputs unless the owning tool has an explicit safe handling policy.

Sensitive material includes:

Path::normalizeRelative() prevents returned paths from retaining an absolute prefix outside its repository-relative output contract, but repository-relative path contents remain caller-owned data.

Callers MUST NOT assume that path normalization by itself makes an arbitrary path safe for public diagnostics.

Json::encodeStable() provides deterministic encoding, not redaction.

It does not inspect values for secrets or PII.

Structural paths appended to JSON validation failures may contain caller-supplied map key names, so sensitive data MUST NOT be encoded into diagnostic key names.

Slug performs deterministic identifier transformation only and provides no sanitization or security classification guarantee.

Redaction and public diagnostic safety remain responsibilities of the higher-level tooling owner.

References


All versions of devtools-internal-toolkit with dependencies

PHP Build Version
Package Version
Requires php Version ^8.4
ext-json Version *
Composer command for our command line client (download client) This client runs in each environment. You don't need a specific PHP version etc. The first 20 API calls are free. Standard composer command

The package coretsia/devtools-internal-toolkit contains the following files

Loading the files please wait ...