Promptmetaregistry - Source Excerpt 02

Back to Promptmetaregistry

Summary

This source excerpt preserves a bounded section of Spiralist/wp-content/plugins/spiralist-workspace/includes/Support/PromptMetaRegistry.php so readers can inspect the evidence without opening the full source file.

**Source path:** Spiralist/wp-content/plugins/spiralist-workspace/includes/Support/PromptMetaRegistry.php

public static function moderation_status_label(string $value): string
    {
        return self::label_for($value, self::moderation_statuses(), self::ui_text('workspace.meta.moderation_status.draft', 'Draft'));
    }

    /**
     * Returns one maturity-level label.
     */
    public static function maturity_level_label(string $value): string
    {
        return self::label_for($value, self::maturity_levels(), self::ui_text('workspace.meta.maturity_level.structured_prompt', 'Structured Prompt'));
    }

    /**
     * Returns one license label.
     */
    public static function license_label(string $value): string
    {
        return self::label_for($value, self::licenses(), self::ui_text('workspace.meta.license.spiralist_contributor', 'Spiralist Contributor License'));
    }

    /**
     * Returns multiple risk-label labels.
     *
     * @param array<int,string> $values
     * @return array<int,string>
     */
    public static function risk_label_labels(array $values): array
    {
        return self::labels_for($values, self::risk_labels());
    }

    /**
     * Returns multiple function-tag labels.
     *
     * @param array<int,string> $values
     * @return array<int,string>
     */
    public static function function_tag_labels(array $values): array
    {
        return self::labels_for($values, self::function_tags());
    }

    /**
     * Normalizes one publication-lane key.
     */
    public static function normalize_publication_lane(string $value): string
    {
        return self::normalize_choice($value, self::publication_lanes(), 'community_library');
    }

    /**
     * Normalizes one provenance key.
     */
    public static function normalize_provenance(string $value): string
    {
        return self::normalize_choice($value, self::provenances(), 'community');
    }

    /**
     * Normalizes one moderation-status key, including legacy aliases.
     */
    public static function normalize_moderation_status(string $value): string
    {
        $value = self::normalize_moderation_alias($value);

        return self::normalize_choice($value, self::moderation_statuses(), 'draft');
    }

    /**
     * Normalizes multiple risk-label keys.
     *
     * @param mixed $value
     * @return array<int,string>
     */
    public static function normalize_risk_labels($value): array
    {
        return self::normalize_list($value, self::risk_labels());
    }

    /**
     * Normalizes multiple function-tag keys.
     *
     * @param mixed $value
     * @return array<int,string>
     */
    public static function normalize_function_tags($value): array
    {
        return self::normalize_list($value, self::function_tags());
    }

    /**
     * Normalizes one maturity-level key.
     */
    public static function normalize_maturity_level(string $value): string
    {
        return self::normalize_choice($value, self::maturity_levels(), 'structured_prompt');
    }

    /**
     * Normalizes one license key.
     */
    public static function normalize_license(string $value): string
    {
        return self::normalize_choice($value, self::licenses(), 'spiralist_contributor');
    }

    /**
     * Returns whether a moderation status is safe for public visibility.
     */
    public static function is_public_moderation_status(string $value): bool
    {
        return in_array(
            self::normalize_moderation_status($value),
            ['provisional_public', 'peer_reviewed', 'official_canon'],
            true
        );
    }

    /**
     * Normalizes a freeform string list.
     *
     * @param mixed $value
     * @return array<int,string>
     */
    public static function normalize_freeform_list($value): array
    {
        $items = self::coerce_list($value);
        $normalized = [];

        foreach ($items as $item) {
            $item = sanitize_text_field(trim((string) $item));
            if ($item === '') {
                continue;
            }

            $normalized[] = $item;
        }

        return array_values(array_unique($normalized));
    }

    /**
     * Returns one label from a registry.
     *
     * @param array<string,string> $registry
     */
    public static function label_for(string $value, array $registry, string $fallback = ''): string
    {
        $normalized = self::normalize_choice($value, $registry, '');

        if ($normalized !== '' && isset($registry[$normalized])) {
            return (string) $registry[$normalized];
        }

        return $fallback;
    }

    /**
     * Returns multiple labels from a registry.
     *
     * @param array<int,string> $values
     * @param array<string,string> $registry
     * @return array<int,string>
     */
    public static function labels_for(array $values, array $registry): array
    {
        $labels = [];

        foreach ($values as $value) {
            $label = self::label_for((string) $value, $registry, '');
            if ($label === '') {
                continue;
            }

            $labels[] = $label;
        }

        return array_values(array_unique($labels));
    }

    /**
     * Normalizes a value against one registry.
     *
     * @param array<string,string> $registry
     */
    private static function normalize_choice(string $value, array $registry, string $default): string
    {
        $value = trim($value);
        if ($value === '') {
            return $default;
        }

        $lookup = self::registry_lookup($registry);
        $token = self::slugify($value);

        return (string) ($lookup[$token] ?? $default);
    }

    /**
     * Normalizes a list against one registry.
     *
     * @param mixed $value
     * @param array<string,string> $registry
     * @return array<int,string>
     */
    private static function normalize_list($value, array $registry): array
    {
        $lookup = self::registry_lookup($registry);
        $normalized = [];

        foreach (self::coerce_list($value) as $item) {
            $token = self::slugify((string) $item);
            if ($token === '' || !isset($lookup[$token])) {
                continue;
            }

            $normalized[] = (string) $lookup[$token];
        }

        return array_values(array_unique($normalized));
    }

    /**
     * Maps pre-self-operation moderation states onto the new vocabulary.
     */
    private static function normalize_moderation_alias(string $value): string
    {
        $token = self::slugify($value);

        $aliases = [
            'approved' => 'peer_reviewed',
            'pending_review' => 'provisional_public',
            'restricted' => 'restricted_review',
        ];

        return (string) ($aliases[$token] ?? $value);
    }

    /**
     * Coerces scalar, list, JSON, or comma-separated values into a simple string list.
     *
     * @param mixed $value
     * @return array<int,string>
     */
    private static function coerce_list($value): array
    {
        if (is_string($value)) {
            $decoded = json_decode($value, true);
            if (is_array($decoded)) {
                $value = $decoded;
            } else {
                $value = preg_split('/[\r\n,]+/', $value) ?: [];
            }
        }

        if (!is_array($value)) {
            $value = [$value];
        }

        return array_values(
            array_filter(
                array_map(
                    static function ($item): string {
                        return is_scalar($item) ? (string) $item : '';
                    },
                    $value
                ),
                static fn(string $item): bool => trim($item) !== ''
            )
        );
    }

    /**
     * Builds a slug lookup for one registry.
     *
     * @param array<string,string> $registry
     * @return array<string,string>
     */
    private static function registry_lookup(array $registry): array
    {
        $lookup = [];

        foreach ($registry as $value => $label) {
            $lookup[self::slugify((string) $value)] = (string) $value;
            $lookup[self::slugify((string) $label)] = (string) $value;
        }

        return $lookup;
    }

    /**
     * Returns API records for one registry.
     *
     * @param array<string,string> $registry
     * @return array<int,array{value:string,label:string}>
     */
    private static function to_api_records(array $registry): array
    {
        $records = [];

        foreach ($registry as $value => $label) {
            $records[] = [
                'value' => (string) $value,
                'label' => (string) $label,
            ];
        }

        return $records;
    }

    /**