@wp-typia/project-tools 0.16.2 → 0.16.4

package/templates/_shared/persistence/core/src/interactivity.ts.mustache

@@ -1,308 +0,0 @@
-import { getContext, store } from '@wordpress/interactivity';
-import { generatePublicWriteRequestId } from '@wp-typia/block-runtime/identifiers';
-
-import { fetchBootstrap, fetchState, writeState } from './api';
-import type {
-	{{pascalCase}}ClientState,
-	{{pascalCase}}Context,
-	{{pascalCase}}State,
-} from './types';
-import type {
-	{{pascalCase}}WriteStateRequest,
-} from './api-types';
-
-function hasExpiredPublicWriteToken(
-	expiresAt?: number
-): boolean {
-	return (
-		typeof expiresAt === 'number' &&
-		expiresAt > 0 &&
-		Date.now() >= expiresAt * 1000
-	);
-}
-
-function getWriteBlockedMessage(
-	context: {{pascalCase}}Context
-): string {
-	return context.persistencePolicy === 'authenticated'
-		? 'Sign in to persist this counter.'
-		: 'Public writes are temporarily unavailable.';
-}
-
-const BOOTSTRAP_MAX_ATTEMPTS = 3;
-const BOOTSTRAP_RETRY_DELAYS_MS = [ 250, 500 ];
-
-async function waitForBootstrapRetry( delayMs: number ): Promise< void > {
-	await new Promise( ( resolve ) => {
-		setTimeout( resolve, delayMs );
-	} );
-}
-
-function getClientState(
-	context: {{pascalCase}}Context
-): {{pascalCase}}ClientState {
-	if ( context.client ) {
-		return context.client;
-	}
-
-	context.client = {
-		bootstrapError: '',
-		writeExpiry: 0,
-		writeNonce: '',
-		writeToken: '',
-	};
-
-	return context.client;
-}
-
-function clearBootstrapError(
-	context: {{pascalCase}}Context,
-	clientState: {{pascalCase}}ClientState
-): void {
-	if ( context.error === clientState.bootstrapError ) {
-		context.error = '';
-	}
-	clientState.bootstrapError = '';
-}
-
-function setBootstrapError(
-	context: {{pascalCase}}Context,
-	clientState: {{pascalCase}}ClientState,
-	message: string
-): void {
-	clientState.bootstrapError = message;
-	context.error = message;
-}
-
-const { actions, state } = store( '{{slugKebabCase}}', {
-	state: {
-		isHydrated: false,
-	} as {{pascalCase}}State,
-
-	actions: {
-		async loadState() {
-			const context = getContext< {{pascalCase}}Context >();
-			if ( context.postId <= 0 || ! context.resourceKey ) {
-				return;
-			}
-
-			context.isLoading = true;
-			context.error = '';
-
-			try {
-				const result = await fetchState( {
-					postId: context.postId,
-					resourceKey: context.resourceKey,
-				}, {
-					transportTarget: 'frontend',
-				} );
-				if ( ! result.isValid || ! result.data ) {
-					context.error = result.errors[ 0 ]?.expected ?? 'Unable to load counter';
-					return;
-				}
-				context.count = result.data.count;
-			} catch ( error ) {
-				context.error =
-					error instanceof Error ? error.message : 'Unknown loading error';
-			} finally {
-				context.isLoading = false;
-			}
-		},
-		async loadBootstrap() {
-			const context = getContext< {{pascalCase}}Context >();
-			const clientState = getClientState( context );
-			if ( context.postId <= 0 || ! context.resourceKey ) {
-				context.bootstrapReady = true;
-				context.canWrite = false;
-				clientState.bootstrapError = '';
-				clientState.writeExpiry = 0;
-				clientState.writeNonce = '';
-				clientState.writeToken = '';
-				return;
-			}
-
-			context.isBootstrapping = true;
-
-			let bootstrapSucceeded = false;
-			let lastBootstrapError =
-				'Unable to initialize write access';
-			const includePublicWriteCredentials = {{isPublicPersistencePolicy}};
-			const includeRestNonce = {{isAuthenticatedPersistencePolicy}};
-
-			for ( let attempt = 1; attempt <= BOOTSTRAP_MAX_ATTEMPTS; attempt += 1 ) {
-				try {
-					const result = await fetchBootstrap( {
-						postId: context.postId,
-						resourceKey: context.resourceKey,
-					}, {
-						transportTarget: 'frontend',
-					} );
-					if ( ! result.isValid || ! result.data ) {
-						lastBootstrapError =
-							result.errors[ 0 ]?.expected ??
-							'Unable to initialize write access';
-						if ( attempt < BOOTSTRAP_MAX_ATTEMPTS ) {
-							await waitForBootstrapRetry(
-								BOOTSTRAP_RETRY_DELAYS_MS[ attempt - 1 ] ?? 750
-							);
-							continue;
-						}
-						break;
-					}
-
-					clientState.writeExpiry =
-						includePublicWriteCredentials &&
-						'publicWriteExpiresAt' in result.data &&
-						typeof result.data.publicWriteExpiresAt === 'number' &&
-						result.data.publicWriteExpiresAt > 0
-							? result.data.publicWriteExpiresAt
-							: 0;
-					clientState.writeToken =
-						includePublicWriteCredentials &&
-						'publicWriteToken' in result.data &&
-						typeof result.data.publicWriteToken === 'string' &&
-						result.data.publicWriteToken.length > 0
-							? result.data.publicWriteToken
-							: '';
-					clientState.writeNonce =
-						includeRestNonce &&
-						'restNonce' in result.data &&
-						typeof result.data.restNonce === 'string' &&
-						result.data.restNonce.length > 0
-							? result.data.restNonce
-							: '';
-					context.bootstrapReady = true;
-					context.canWrite =
-						result.data.canWrite === true &&
-						(
-							context.persistencePolicy === 'authenticated'
-								? clientState.writeNonce.length > 0
-								: clientState.writeToken.length > 0 &&
-									! hasExpiredPublicWriteToken( clientState.writeExpiry )
-						);
-					clearBootstrapError( context, clientState );
-					bootstrapSucceeded = true;
-					break;
-				} catch ( error ) {
-					lastBootstrapError =
-						error instanceof Error ? error.message : 'Unknown bootstrap error';
-					if ( attempt < BOOTSTRAP_MAX_ATTEMPTS ) {
-						await waitForBootstrapRetry(
-							BOOTSTRAP_RETRY_DELAYS_MS[ attempt - 1 ] ?? 750
-						);
-						continue;
-					}
-					break;
-				}
-			}
-
-			if ( ! bootstrapSucceeded ) {
-				context.bootstrapReady = false;
-				context.canWrite = false;
-				clientState.writeExpiry = 0;
-				clientState.writeNonce = '';
-				clientState.writeToken = '';
-				setBootstrapError( context, clientState, lastBootstrapError );
-			}
-			context.isBootstrapping = false;
-		},
-		async increment() {
-			const context = getContext< {{pascalCase}}Context >();
-			const clientState = getClientState( context );
-			if ( context.postId <= 0 || ! context.resourceKey ) {
-				return;
-			}
-			if ( ! context.bootstrapReady ) {
-				await actions.loadBootstrap();
-			}
-			if ( ! context.bootstrapReady ) {
-				context.error = 'Write access is still initializing.';
-				return;
-			}
-			if (
-				context.persistencePolicy === 'public' &&
-				hasExpiredPublicWriteToken( clientState.writeExpiry )
-			) {
-				await actions.loadBootstrap();
-			}
-			if (
-				context.persistencePolicy === 'public' &&
-				hasExpiredPublicWriteToken( clientState.writeExpiry )
-			) {
-				context.canWrite = false;
-				context.error = getWriteBlockedMessage( context );
-				return;
-			}
-			if ( ! context.canWrite ) {
-				context.error = getWriteBlockedMessage( context );
-				return;
-			}
-
-			context.isSaving = true;
-			context.error = '';
-
-			try {
-				const request = {
-					delta: 1,
-					postId: context.postId,
-					resourceKey: context.resourceKey,
-				} as {{pascalCase}}WriteStateRequest;
-				if ( {{isPublicPersistencePolicy}} ) {
-					request.publicWriteRequestId =
-						generatePublicWriteRequestId() as {{pascalCase}}WriteStateRequest[ 'publicWriteRequestId' ];
-					if ( clientState.writeToken.length > 0 ) {
-						request.publicWriteToken =
-							clientState.writeToken as {{pascalCase}}WriteStateRequest[ 'publicWriteToken' ];
-					}
-				}
-				const result = await writeState( request, {
-					restNonce:
-						clientState.writeNonce.length > 0
-							? clientState.writeNonce
-							: undefined,
-					transportTarget: 'frontend',
-				} );
-				if ( ! result.isValid || ! result.data ) {
-					context.error = result.errors[ 0 ]?.expected ?? 'Unable to update counter';
-					return;
-				}
-				context.count = result.data.count;
-				context.storage = result.data.storage;
-			} catch ( error ) {
-				context.error =
-					error instanceof Error ? error.message : 'Unknown update error';
-			} finally {
-				context.isSaving = false;
-			}
-		},
-	},
-
-	callbacks: {
-		init() {
-			const context = getContext< {{pascalCase}}Context >();
-			context.client = {
-				bootstrapError: '',
-				writeExpiry: 0,
-				writeNonce: '',
-				writeToken: '',
-			};
-			context.bootstrapReady = false;
-			context.canWrite = false;
-			context.count = 0;
-			context.error = '';
-			context.isBootstrapping = false;
-			context.isLoading = false;
-			context.isSaving = false;
-		},
-		mounted() {
-			state.isHydrated = true;
-			if ( typeof document !== 'undefined' ) {
-				document.documentElement.dataset[ '{{slugCamelCase}}Hydrated' ] = 'true';
-			}
-			void Promise.allSettled( [
-				actions.loadState(),
-				actions.loadBootstrap(),
-			] );
-		},
-	},
-} );

package/templates/_shared/persistence/core/src/save.tsx.mustache

@@ -1,5 +0,0 @@
-export default function Save() {
-	// This block is intentionally server-rendered. PHP bootstraps post context,
-	// storage-backed state, and write-policy data before the frontend hydrates.
-	return null;
-}

package/templates/_shared/persistence/core/src/validators.ts.mustache

@@ -1,43 +0,0 @@
-import typia from 'typia';
-import currentManifest from './typia.manifest.json';
-import type {
-	{{pascalCase}}Attributes,
-	{{pascalCase}}ValidationResult,
-} from './types';
-import { generateResourceKey } from '@wp-typia/block-runtime/identifiers';
-import { createTemplateValidatorToolkit } from './validator-toolkit';
-
-const scaffoldValidators = createTemplateValidatorToolkit< {{pascalCase}}Attributes >( {
-	assert: typia.createAssert< {{pascalCase}}Attributes >(),
-	clone: typia.misc.createClone< {{pascalCase}}Attributes >() as (
-		value: {{pascalCase}}Attributes,
-	) => {{pascalCase}}Attributes,
-	is: typia.createIs< {{pascalCase}}Attributes >(),
-	manifest: currentManifest,
-	prune: typia.misc.createPrune< {{pascalCase}}Attributes >(),
-	random: typia.createRandom< {{pascalCase}}Attributes >() as (
-		...args: unknown[]
-	) => {{pascalCase}}Attributes,
-	finalize: ( normalized ) => ( {
-		...normalized,
-		resourceKey:
-			normalized.resourceKey && normalized.resourceKey.length > 0
-				? normalized.resourceKey
-				: generateResourceKey( '{{slugKebabCase}}' ),
-	} ),
-	validate: typia.createValidate< {{pascalCase}}Attributes >(),
-} );
-
-export const validators = scaffoldValidators.validators;
-
-export const validate{{pascalCase}}Attributes =
-	scaffoldValidators.validateAttributes as (
-		attributes: unknown
-	) => {{pascalCase}}ValidationResult;
-
-export const sanitize{{pascalCase}}Attributes =
-	scaffoldValidators.sanitizeAttributes as (
-		attributes: Partial< {{pascalCase}}Attributes >
-	) => {{pascalCase}}Attributes;
-
-export const createAttributeUpdater = scaffoldValidators.createAttributeUpdater;

package/templates/basic/src/block.json.mustache

@@ -1,51 +0,0 @@
-{
-	"$schema": "https://schemas.wp.org/trunk/block.json",
-	"apiVersion": 3,
-	"name": "{{namespace}}/{{slug}}",
-	"version": "{{blockMetadataVersion}}",
-	"title": "{{title}}",
-	"category": "{{category}}",
-	"icon": "{{icon}}",
-	"description": "{{description}}",
-	"keywords": ["{{keyword}}", "typia", "block"],
-	"example": {
-		"attributes": {
-			"content": "Example content",
-			"alignment": "center",
-			"isVisible": true
-		}
-	},
-	"supports": {
-		"html": false
-	},
-	"textdomain": "{{textDomain}}",
-	"editorScript": "file:./index.js",
-	"editorStyle": "file:./index.css",
-	"style": "file:./style-index.css",
-	"attributes": {
-		"content": {
-			"type": "string",
-			"default": ""
-		},
-		"alignment": {
-			"type": "string",
-			"enum": ["left", "center", "right", "justify"],
-			"default": "left"
-		},
-		"className": {
-			"type": "string",
-			"default": ""
-		},
-		"isVisible": {
-			"type": "boolean",
-			"default": true
-		},
-		"id": {
-			"type": "string"
-		},
-		"schemaVersion": {
-			"type": "number",
-			"default": 1
-		}
-	}
-}

package/templates/basic/src/edit.tsx.mustache

@@ -1,128 +0,0 @@
-/**
- * Editor component for {{title}} Block
- */
-
-import { BlockEditProps } from '@wordpress/blocks';
-import {
-  InspectorControls,
-  RichText,
-  useBlockProps,
-} from '@wordpress/block-editor';
-import { Notice, PanelBody, TextControl } from '@wordpress/components';
-import { __ } from '@wordpress/i18n';
-import currentManifest from './typia.manifest.json';
-import {
-  InspectorFromManifest,
-  type ManifestDocument,
-  useEditorFields,
-  useTypedAttributeUpdater,
-} from '@wp-typia/block-runtime/inspector';
-import { {{pascalCase}}Attributes } from './types';
-import {
-  sanitize{{pascalCase}}Attributes,
-  validate{{pascalCase}}Attributes,
-} from './validators';
-import { useTypiaValidation } from './hooks';
-
-type EditProps = BlockEditProps<{{pascalCase}}Attributes>;
-
-function Edit({ attributes, setAttributes }: EditProps) {
-  const isVisible = attributes.isVisible !== false;
-  const blockProps = useBlockProps({
-    className: `{{cssClassName}}${isVisible ? '' : ' is-hidden'}`,
-  });
-  const editorFields = useEditorFields(currentManifest as ManifestDocument, {
-    hidden: ['id', 'schemaVersion'],
-    manual: ['content'],
-    labels: {
-      alignment: __('Alignment', '{{textDomain}}'),
-      className: __('CSS Class', '{{textDomain}}'),
-      content: __('Content', '{{textDomain}}'),
-      isVisible: __('Visible', '{{textDomain}}'),
-    },
-  });
-  const classNameField = editorFields.getField('className');
-  const { errorMessages, isValid } = useTypiaValidation(
-    attributes,
-    validate{{pascalCase}}Attributes
-  );
-  const validateEditorUpdate = (nextAttributes: {{pascalCase}}Attributes) => {
-    try {
-      return {
-        data: sanitize{{pascalCase}}Attributes(nextAttributes),
-        errors: [],
-        isValid: true as const,
-      };
-    } catch {
-      return validate{{pascalCase}}Attributes(nextAttributes);
-    }
-  };
-  const { updateField } = useTypedAttributeUpdater(
-    attributes,
-    setAttributes,
-    validateEditorUpdate
-  );
-
-  return (
-    <>
-      <InspectorControls>
-        <InspectorFromManifest
-          attributes={attributes}
-          fieldLookup={editorFields}
-          onChange={updateField}
-          paths={['alignment', 'isVisible']}
-          title={__('Settings', '{{textDomain}}')}
-        >
-          <TextControl
-            label={__('Content', '{{textDomain}}')}
-            value={attributes.content || ''}
-            onChange={(value) => updateField('content', value)}
-            help={__('Mirrors the main block content.', '{{textDomain}}')}
-          />
-
-          <TextControl
-            label={classNameField?.label || __('CSS Class', '{{textDomain}}')}
-            value={attributes.className || ''}
-            onChange={(value) => updateField('className', value)}
-            help={__('Add an optional CSS class name.', '{{textDomain}}')}
-          />
-        </InspectorFromManifest>
-
-        {!isValid && (
-          <PanelBody title={__('Validation Errors', '{{textDomain}}')} initialOpen>
-            {errorMessages.map((error, index) => (
-              <div key={index} style={{ color: '#cc1818', fontSize: '12px' }}>
-                • {error}
-              </div>
-            ))}
-          </PanelBody>
-        )}
-      </InspectorControls>
-
-      <div {...blockProps}>
-        <div className="{{cssClassName}}__content">
-          <RichText
-            tagName="p"
-            value={attributes.content || ''}
-            onChange={(value) => updateField('content', value)}
-            placeholder={__('Add your content...', '{{textDomain}}')}
-          />
-        </div>
-        {!isValid && (
-          <Notice status="error" isDismissible={false}>
-            <p>
-              <strong>{__('Validation Errors', '{{textDomain}}')}</strong>
-            </p>
-            <ul style={{ margin: 0, paddingLeft: '1em' }}>
-              {errorMessages.map((error, index) => (
-                <li key={index}>{error}</li>
-              ))}
-            </ul>
-          </Notice>
-        )}
-      </div>
-    </>
-  );
-}
-
-export default Edit;

package/templates/basic/src/index.tsx.mustache

@@ -1,45 +0,0 @@
-/**
- * WordPress {{title}} Block
- *
- * Typia-powered type-safe block
- */
-
-import { registerBlockType } from '@wordpress/blocks';
-import type { BlockConfiguration } from '@wordpress/blocks';
-import type { BlockSupports } from '@wp-typia/block-types/blocks/supports';
-import { __ } from '@wordpress/i18n';
-import {
-  buildScaffoldBlockRegistration,
-  type ScaffoldBlockMetadata,
-} from '@wp-typia/block-runtime/blocks';
-
-// Import components
-import Edit from './edit';
-import Save from './save';
-import metadata from './block.json';
-import './editor.scss';
-import './style.scss';
-
-// Import types
-import { {{pascalCase}}Attributes } from './types';
-import { validators } from './validators';
-
-const scaffoldSupports = {
-  html: false,
-  multiple: true,
-  align: ['wide', 'full'],
-} satisfies BlockSupports;
-
-// Register the block
-const registration = buildScaffoldBlockRegistration<
-  BlockConfiguration<{{pascalCase}}Attributes>
->(metadata as ScaffoldBlockMetadata, {
-  supports: scaffoldSupports,
-  example: {
-    attributes: validators.random(),
-  },
-  edit: Edit,
-  save: Save,
-});
-
-registerBlockType<{{pascalCase}}Attributes>(registration.name, registration.settings);

package/templates/basic/src/save.tsx.mustache

@@ -1,30 +0,0 @@
-/**
- * Save/Frontend component for {{title}} Block
- */
-
-import { RichText, useBlockProps } from '@wordpress/block-editor';
-import { {{pascalCase}}Attributes } from './types';
-
-interface SaveProps {
-  attributes: {{pascalCase}}Attributes;
-}
-
-export default function Save({ attributes }: SaveProps) {
-  const isVisible = attributes.isVisible !== false;
-  const blockProps = useBlockProps.save({
-    className: `{{cssClassName}}${isVisible ? '' : ' is-hidden'}`,
-    hidden: isVisible ? undefined : true,
-    'aria-hidden': isVisible ? undefined : 'true',
-  });
-
-  return (
-    <div {...blockProps}>
-      <div
-        className="{{cssClassName}}__content"
-        data-align={attributes.alignment || 'left'}
-      >
-        <RichText.Content tagName="p" value={attributes.content} />
-      </div>
-    </div>
-  );
-}

package/templates/basic/src/types.ts.mustache

@@ -1,56 +0,0 @@
-import type { TextAlignment } from "@wp-typia/block-types/block-editor/alignment";
-import type {
-  TypiaValidationError,
-  ValidationResult,
-} from "@wp-typia/block-runtime/validation";
-import { tags } from "typia";
-
-export type { TypiaValidationError, ValidationResult } from "@wp-typia/block-runtime/validation";
-
-/**
- * Block attributes interface
- * Typia tags define runtime validation rules
- */
-export interface {{pascalCase}}Attributes {
-  /**
-   * Main block content
-   */
-  content: string & 
-    tags.MinLength<1> & 
-    tags.MaxLength<1000> & 
-    tags.Default<"">;
-
-  /**
-   * Alignment
-   */
-  alignment?: TextAlignment & 
-    tags.Default<"left">;
-
-  /**
-   * Visibility toggle
-   */
-  isVisible?: boolean & 
-    tags.Default<true>;
-
-  /**
-   * Custom CSS class
-   */
-  className?: string & 
-    tags.MaxLength<100> & 
-    tags.Default<"">;
-
-  /**
-   * Generated runtime ID
-   */
-  id?: string & 
-    tags.Format<"uuid">;
-
-  /**
-   * Block version for migrations
-   */
-  schemaVersion?: number & 
-    tags.Type<"uint32"> & 
-    tags.Default<1>;
-}
-
-export type {{pascalCase}}ValidationResult = ValidationResult<{{pascalCase}}Attributes>;